Mas eu volto depois de terminar o teste.
Vamos dar uma olhada no patch dessas instruções.
Agora estamos bastante familiarizados com o funcionamento deles, mas como podemos corrigi-los para modificar o comportamento
do aplicativo para entrar em outras ramificações ou coisas assim?
De modo geral, há vários métodos.
Apresentei três deles porque acho que, sim, com esses três você resolverá todas as tarefas que
deseja realizar.
Muito bem, vamos nos aprofundar na primeira.
O primeiro método é a lógica.
O flipping parece promissor.
Vamos ver como isso funciona.
Está bem.
No lado direito, temos nosso código Java e, no lado esquerdo, temos o código do smiley correspondente.
Vamos dar uma olhada nisso.
Estamos criando um novo objeto de jogo aqui.
Em seguida, o jogador é atingido.
Portanto, no último exercício, perdemos a vida de um jogador aqui.
Mas agora há algo diferente.
O jogador agora tem um novo campo de instância chamado Shield (Escudo).
Você tem uma ideia do que faremos nos próximos vídeos?
Sim, com certeza.
Portanto, nesse caso, nosso jogador agora tem uma nova instância, Field Shield.
E se o jogador tiver um escudo e for atingido, ele não perderá uma vida, o escudo será
removido.
Portanto, o escudo do jogador agora é igual a falso.
E seguimos em frente em nosso código, caso não tenhamos um escudo.
Portanto, se o escudo do jogador for falso, o jogador perderá uma vida e devemos seguir em frente com o nosso código.
Tudo bem.
Vamos dar uma olhada no código do smiley.
Portanto, nesta linha, temos v um inicializado com 0x1 e, em seguida, temos um booleano I get.
Portanto, estamos obtendo essa instância do escudo de pensamento do jogador, que é do tipo booleano para V dois.
E agora temos a declaração if e essa declaração if é, por favor, leia em voz alta.
Se V dois for igual a zero, pule para a condição zero.
Então, é assim.
Agora precisamos dar um passo atrás e pensar sobre isso.
Vamos ver o que estamos verificando.
Está bem.
Estamos verificando se você está com um escudo.
O escudo é do tipo booleano.
Isso significa que o escudo pode ser verdadeiro ou falso.
Se agora estamos fazendo uma comparação com zero, isso significa que estamos verificando se
o jogador não tem um escudo, porque se o escudo for zero, então é falso.
E essa é a comparação com o zero.
Portanto, essa afirmação teria sido ou seria verdadeira.
Tudo bem.
Portanto, esta é a nossa declaração.
Se não tivermos um escudo, então você chegará à condição zero.
Vejamos.
A condição de zeros aqui está sendo usada para trazer os pontos de vida dos jogadores para o V dois.
Estamos subtraindo um desse valor.
Estamos colocando-o de volta e depois retornaremos.
Muito bem, isso parece bom.
Caso contrário, vamos dar uma olhada.
Portanto, se estivermos tendo um escudo, isso significa que não é igual a zero.
Em seguida, podemos ver que b um é inicializado com zero e estamos colocando nosso estado de escudo, desculpe, estado de escudo em zero, o que significa
que o escudo de esquiva do jogador agora está para frente.
Assim, perdemos nosso escudo.
Mas não perdemos uma vida com essa abordagem.
Está bem.
Em seguida, saltamos para o zero, que é aqui, e voltamos para fora.
Tudo bem.
Parece bom para mim.
Agora, vamos ver como podemos corrigir esse código para obter uma vantagem com isso.
Portanto, há muitas abordagens diferentes que podemos fazer.
No meu caso, quero falar sobre inverter a lógica, o que significa que, se não tivermos um escudo, não seremos
atingidos.
E se estivermos usando um escudo, seremos atingidos.
Tudo bem.
Como podemos fazer isso com apenas uma instrução lá?
Pense nas declarações if e em todos esses tipos diferentes.
Podemos usar isso para mudar o comportamento?
Absolutamente correto.
Podemos fazer isso e o fazemos com o seguinte sinal.
Estamos adicionando esse ponto de exclamação e, ao fazer isso, inverteremos a lógica.
Nosso se for igual a zero se tornará, se não for igual, zero.
E vamos classificar essa abordagem mais uma vez.
Qual é a aparência?
Portanto, ainda temos um um em nosso registro v um, agora estamos colocando nosso escudo de ponto de jogador em v dois.
Não estamos tendo um escudo no momento.
Portanto, essa declaração ou v duas está segurando o Yeah.
O valor false.
Agora temos, isso se torna uma tarefa um pouco mais complexa.
Portanto, está ficando um pouco complicado.
Mas vamos ver, vamos fazer isso mais uma vez.
Se V dois, que é falso, não for igual a zero, passaremos para a condição zero.
Tudo bem.
Mais uma vez, se nós dois não formos iguais a zero, passaremos para a condição zero.
Está bem?
Isso significa que, se o nosso V zero não for igual a zero, passaremos para a condição zero.
Portanto, em nosso caso, o v2 não é verdadeiro.
V dois é falso.
Portanto, não saltamos para a condição zero.
Ok, então vamos em frente.
Aqui, estamos colocando zero em v um e, em seguida, colocamos falso novamente em nosso estado de escudo do
jogador.
E isso é ridículo, pois significa que ainda mantemos o escudo do jogador ativado porque invertemos a lógica,
pois, como o escudo do jogador é igual a falso, não podemos ser atingidos.
E isso é bom porque, sim, estamos colocando esse valor aqui mais uma vez.
Portanto, ele não é substituído.
Portanto, ainda temos nosso escudo ou escudo imaginário aqui, mas ele nos protegerá.
Então, isso é bom.
Está bem.
E depois saímos disso.
Portanto, inverter uma lógica torna tudo muito complicado.
Portanto, sim, temos que dizer isso em voz alta e pensar sobre o que queremos verificar e o que fizemos.
Normalmente.
Se você entendeu a declaração if inicial e deseja ter o oposto disso, pode simplesmente inverter
a situação sem nem mesmo pensar nisso.
Ao pensar nisso, você pode ficar um pouco confuso depois, mas perceberá que ainda está
correto.
Então, sim, é isso que temos aqui.
E isso é algo que queremos codificar agora mesmo e depois analisar novamente, porque é realmente complicado.
Eu sei, mas nós praticamos isso.
É por isso que você está aqui.
E juntos faremos isso.
E depois disso, você pode fazer muitas coisas engraçadas.
Aprenderemos alguns outros métodos, que às vezes podem ser um pouco mais fáceis.
Mas, por enquanto, vamos nos ater a este.
Está bem?
Antes de codificá-lo, vamos fazê-lo mais uma vez juntos.
Vamos fazer isso para o estado inicial.
Se B dois for igual a zero, saltamos para nossa condição.
Zero.
Isso significa que não teremos um escudo de jogador.
Agora, corrigimos essa instrução com o ponto de exclamação e, portanto, mudamos o igual a zero para diferente
de zero.
Isso significa que, a menos que não tenhamos um escudo de jogador, não perdemos uma linha.
Para mim, também não é fácil fazer isso.
Portanto, tenho que pensar sobre isso.
Mas, ao pensar sobre, obtemos a solução.
Está bem.
Muito bem, agora vamos voltar à nossa VM do Ubuntu e o código é bem rápido.
Aqui adicionamos nossa VM do Ubuntu e ainda temos esse projeto antigo aberto.
Vejamos.
Sim, temos que verificar a pontuação máxima e temos que ser atingidos aqui.
Muito bem, vamos escrever esse trecho de código para implementar o fato de que fomos cortados.
Portanto, estamos tendo um novo campo de instância e um corte booleano.
Vamos definir isso como verdadeiro porque, assim, começaremos com um escudo e, se formos atingidos, não deveremos
perder a vida; depois, removeremos o escudo e, se formos atingidos novamente, perderemos a vida.
Muito bem.
Então vamos ver.
Agora estamos em nosso método de acerto.
Portanto, se esse ponto cortado for igual a verdadeiro, não seremos atingidos de outra forma.
Que está nesta outra parte aqui.
Nós somos atingidos.
Está bem.
Depois de ser atingido e ter um escudo, precisamos remover o escudo porque ele bloqueou essa
colisão.
Portanto, esse escudo é igualmente falso.
E aqui também podemos ver uma possibilidade de patch adicional, que sim.
É muito útil para nós.
Digamos que não estamos removendo nosso escudo, portanto, digamos que este permaneça verdadeiro.
Isso significaria que, se você pegar um escudo uma vez, ele não será removido.
Portanto, ele fica lá para sempre até terminarmos o jogo.
Esse também seria um ótimo patch, mas com uma pequena desvantagem.
Temos que pegar o escudo primeiro e isso é algo que não queremos fazer.
Sejamos superpreguiçosos e queremos começar com tudo o que desejamos ter.
Portanto, é um bom patch, mas não é o que estamos procurando.
Tudo bem.
Portanto, esse está definido como falso.
Depois disso, somos atingidos e esse é o nosso código.
E vamos experimentar isso.
Então, clicamos em Build.
E também estou fazendo a conexão ADB com nossa VM.
Já conectado.
Isso é bom.
Mudança de local.
Aqui está.
E sim, vamos instalar esse aplicativo.
Cópia da tela.
Aqui está.
Smiley to.
Este é o nosso aplicativo.
Vejamos.
Portanto, agora estamos tendo um escudo.
Isso significa que, se formos atingidos ou se você pressionar o botão, seremos atingidos.
Mas temos nosso escudo.
Portanto, não devemos perder uma vida.
Eles devem chegar em cinco minutos depois.
Cinco vidas.
Vejamos.
Agora somos atingidos em três, dois, um.
Tudo bem.
Legal.
Está funcionando.
Agora perdemos nosso escudo.
Podemos nos livrar disso de forma oculta.
Pressionando esse botão mais uma vez.
Sim.
Agora está reduzindo a lista.
Tudo bem.
Vamos verificar rapidamente se isso está realmente correto.
Então, vamos fechar esse aqui.
Está bem.
E agora vamos remover esse escudo.
Nós o construímos mais uma vez.
Está bem.
Localize a depuração do aplicativo de instalação do ADB.
Estamos abertos.
Abrindo-o.
Se ele conseguir isso agora, não teremos um escudo.
Portanto, devemos perder uma vida.
E deve haver um quatro.
Vejamos.
Três, dois, um.
Sim.
Está bem.
Fico feliz que isso tenha funcionado.
Caso contrário, eu tinha que descobrir o que estava errado.
Mas é exatamente isso que queremos ter.
Tudo bem.
Com relação ao estado, isso realmente não importa, pois o estado muda no jogo várias
vezes.
Vamos dar uma olhada nisso aqui.
Sim, essa instrução if e como corrigir isso.
Portanto, vou descompilar esse aplicativo e, em seguida, usaremos nossa mesa digitalizadora.
Portanto, antes de descompilarmos esse aplicativo, eu realmente gostaria de acrescentar algo.
Portanto, este não é um curso de desenvolvimento para Android, e o que mostrei até agora é perfeitamente adequado
para criar aplicativos simples de maquete para testar ou treinar um tópico especial, como condições if. No entanto, esses aplicativos
podem não parecer tão sofisticados, ou digamos que sejam um pouco entediantes, e por isso também forneci uma versão
mais sofisticada desse aplicativo aqui.
O código é praticamente idêntico, portanto, a única diferença é que a versão smiley to design tem um botão adicional
para pegar um escudo e alguma forma de saída visual.
Você pode fazer exatamente o mesmo no aplicativo de maquete com algum tipo de instrução de depuração.
Por exemplo, System. fora. println.
Isso também é perfeitamente aceitável.
Portanto, para que o aplicativo de Petra comece com o Escudo, recomendo usar a versão Smiley para
projetar ou definir o estado do Escudo como falso em nossa versão de maquete.
Também forneço todos os três aplicativos desta seção como anexo na versão Smiley to design, e você
tem algum tipo de resultado visual na versão smiley to no shield.
Você não deve perder uma vida depois de corrigi-lo.
Não importa em qual versão você aplica o patch.
Tudo o que importa é que entendemos como a inversão da lógica afeta nosso aplicativo e que podemos
alcançar o que queremos nele.
Porque, mais tarde, levaremos nossa abordagem para aplicativos do mundo real, por exemplo, para contornar a detecção
de rotina ou para modificar nosso aplicativo de banco de espaço para obter determinados recursos.
Muito bem, perfeito.
Vamos reverter isso rapidamente e, em seguida, descobriremos como podemos corrigir isso para obter um escudo permanente.
Está bem.
Desta vez, também tentei escrever de forma um pouco mais limpa, para que não ficasse tão bagunçado, mas não tenho certeza
se isso vai funcionar bem, então vamos ver.
Muito bem, temos nosso método aqui.
Seja atingido.
Portanto, aqui temos o nome do nosso método.
Podemos ver zero parâmetros e retornar branco.
Esse é o nosso protótipo de função.
Och, então temos, I get e temos esse objeto aqui, então p zero é esse I get significa que temos um campo de instância, então temos
isso e aqui está nosso campo de instância e esse escudo de pontos.
E isso está sendo colocado em re zero.
Está bem.
Portanto, zeramos agora esse pensamento compartilhado.
Está bem.
Então, temos we one que está sendo inicializado com zero e temos b two que também está sendo inicializado
com B two.
A propósito, eu pulei essa parte, mas já estamos familiarizados com isso, então acho que não
preciso mais explicar sobre os três locais.
Talvez você esteja entediado com esse assunto, e eu entendo perfeitamente.
Ok, voltando ao assunto.
Estamos dentro do B1.
Nós um agora é zero e B dois agora é um.
Está bem.
Em seguida, temos nossa instrução if.
Então, vamos nos ater a essa cor dramática aqui e vamos ler isso em voz alta juntos.
Se o zero não for igual, vamos para.
Se zerarmos, não é igual a nós.
Em seguida, saltamos para essa condição, e essa condição está aqui.
Então, vamos pular para este aqui.
Está bem.
Vamos verificar do que se trata B0 é o nosso escudo de esquiva.
Portanto, se essa esquiva estiver aqui.
Está bem.
Minha promessa.
Acho que já acabou.
Então, vamos ver se ela.
Não é igual.
E nós também somos verdadeiros.
Ops.
Aqui está.
Ok, esta é a nossa declaração if.
Portanto, se essa planilha não for igualmente verdadeira, parece um pouco estranho, mas vamos descobrir do que
se trata.
Vejamos.
Então chegamos a este.
Entendo que estamos buscando p zero.
Este aqui é o nosso this back novamente neste dot lives e estamos buscando esse valor e colocando-o
em v zero.
Portanto, zeramos.
Oh, isso é interessante.
Vamos mudar a cor.
Zero.
Esse pensamento é vivo?
Então, por que isso é interessante?
Porque estamos sobrescrevendo v zero nesse ponto aqui.
Portanto, aqui nós zeramos a referência a esse escudo de pontos, mas agora ele está sendo substituído por esse ponto vivo.
Portanto, tome cuidado.
Sobrescrito.
E sim, se mantivermos o controle desses registros dessa forma, não teremos nenhum problema.
Portanto, nós sabemos.
Ok, o zero agora é a vida.
Está bem.
Portanto, estamos nessa linha aqui.
Então, estamos subtraindo.
O zero é igual a zero menos v dois.
Portanto, estamos subtraindo o dois do zero e armazenando o resultado de volta em v zero.
Nós zero é agora nós zero menos v dois que é v zero é agora esse ponto vive.
Esse pensamento vive tão abstraído com um.
Sim, este aqui.
Menos um.
Está bem.
E depois.
Sim.
Estamos repondo esse valor novamente.
E você pode ver esses padrões.
Você.
Você já viu isso no passado e verá isso também em alguns outros exemplos.
E ao praticar o smiley, você identifica imediatamente esses padrões.
Portanto, estamos obtendo esse valor.
Estamos subtraindo um e, em seguida, colocando-o de volta.
Isso é simplesmente uma abstração de um desses campos de instância.
Está bem.
Isso significa que esse ponto vive, que agora é p zero.
Portanto, esse ponto está vivo.
Bem, desculpe, vamos mudar a cor para isso, porque não estamos tendo o zero nesse caso.
Estamos tendo p zero como igual a v 0. 0. vidas para ser mais correto.
Está bem.
Portanto.
Essa ação está viva.
Agora é igual a v zero.
Tudo bem.
Apenas subtraímos um das vidas iniciais e o colocamos novamente nesta.
Está bem.
Em seguida, temos outra declaração.
Este aqui.
Então vamos ver.
Se zerarmos como menos igual a zero, saltamos para essa condição.
Portanto, se zerarmos.
É menos igual.
Zero.
Nós nos adaptamos a essa condição.
Nessa condição, está aqui.
Ok, vamos recapitular isso.
O que é zero, zero, zero é nossa vida neste ponto, como posso ver daqui.
Sim.
O zero foi referenciado pela última vez nesta linha aqui, portanto, esta foi a última vez que fizemos referência
ou sim.
Inicializado com zero.
O valor atribuído não é inicializado para ser zero.
E isso significa que esta é a nossa vida neste ponto, esta vida neste ponto.
Se esse ponto vive for menor que igual, zero.
Sim.
Isso significa que estamos prestes a perder o jogo.
Vejamos.
Em seguida, estamos colocando nós um nesse aqui, p zero e agora são p zeros nesse objeto.
Portanto, aqui e aqui temos nosso campo de instância, esse estado de ponto.
Está bem.
Este estado.
Agora estamos colocando o V-1 nisso.
O que queremos é zero zero.
Está bem.
Mas estamos investindo em ouro nisso.
Isso significa que não estamos tendo zero.
Sim, estamos tendo zero.
Mas, neste caso, estamos tendo falhas.
Portanto, esse estado é uma falha posterior.
Está bem.
Depois, temos o nosso favorito.
Mas essa não é a nossa instrução principal.
Esse é apenas o nosso rótulo que pode ser ignorado.
E, então, estamos simplesmente retornando para fora dessa função.
Portanto, retorne depois.
Tudo bem.
E é isso.
Portanto, agora temos a declaração verdadeira para esse caso aqui.
Agora precisamos fazer o mesmo com a declaração falsa.
Portanto, estamos tendo nossos ls.
E sim, espero que não seja tão longo, mas vamos descobrir.
Primeiro, quero fazer uma limpeza rápida.
Bem, lá vamos nós.
Tudo bem.
Está bem.
Portanto, temos essa condição.
Portanto, não estamos pulando no momento.
Estamos seguindo em frente nesta parte.
Agora estamos colocando V0 em p zero.
Esse é mais uma vez o nosso campo de instância.
Esse pensamento também permaneceu.
Portanto, esse estado agora é nós dois ou eu percebo que eles são. Não tenho certeza por que escrevi dessa forma.
Normalmente, eu não faço isso.
Portanto, vamos limpar essa realidade.
Sim.
Não sei ao certo por que escrevi o zero ali.
Não gosto de fazer isso porque perdemos o controle dos registros e, sim, desculpe-me por isso, mas agora estamos de volta
ao caminho certo.
Temos que colocar I e we para entrar nesse estado de ponto.
Está bem.
Estamos nessa linha.
Sim.
E nós dois agora é verdade.
Isso faz sentido.
Portanto, agora estamos colocando true em nosso estado this dot e, em seguida, temos esse rótulo go to e também a instrução
go to, que é ainda mais importante, porque agora sabemos que saltamos por isso, vamos para baixo e depois
retornamos.
Está bem.
Então é isso para a declaração aqui.
Agora temos esse bloco completo.
Temos os dois.
Vamos fazer isso aqui.
Portanto, temos os dois ramos.
Temos o ramo verdadeiro e o falso.
Precisamos repetir isso para este aqui.
Espero que não seja tão grande, mas vou minimizá-lo um pouco para que possamos escrever aqui
neste estado limpo.
Ok, estamos de volta.
Vejamos.
Estamos nessa declaração aqui.
Já temos essa parte.
Portanto, aqui estamos prontos.
Mas precisamos voltar à declaração padrão aqui.
E esta é a parte de baixo.
Portanto, essa é a nossa declaração if.
E agora temos o else, que é a parte falsa em relação à parte falsa.
Seguimos em frente aqui mesmo.
Vejamos, estamos colocando B um em P zero.
Então, novamente, este é o nosso objeto e é este escudo de pontos.
Tudo bem.
Portanto, nesta planilha de pontos, espero que o espaço seja suficiente.
Vejamos, agora é igual a um.
Vamos ver o que mais temos.
O que queremos é falso.
Legal.
Falso.
Muito bem.
Ok, legal.
Em seguida, temos nosso rótulo de destino e esse rótulo de destino, que podemos ver aqui.
Sim.
Portanto, estamos pulando aqui para baixo e, em seguida, estamos simplesmente retornando para fora dessa função.
Ah, tudo bem.
Isso é bom.
Portanto, estamos prontos.
Está bem.
Portanto, este é o nosso código.
Ele se ajusta a esta página, o que me deixa muito feliz.
Então, vamos ver o que esse código faz e como podemos tirar proveito dele.
Vamos recapitular isso primeiro.
Então, temos nosso objeto jogador aqui.
Esse é o nosso jogador.
E esse jogador não começa com um escudo.
Se formos atingidos por um tiro, por exemplo, perderemos uma vida.
Portanto, se esse nos atingir, perderemos uma vida.
Está bem.
E se estivermos pegando uma moeda.
Então, sim, não escrevemos o código referente à moeda, mas é quando o estado do escudo do jogador
muda, pelo menos para o aplicativo de ping espacial.
Portanto, temos nosso painel de espaço e agora estamos buscando uma moeda nesse código.
Desculpe.
Em seguida, colocamos nosso escudo de jogadores ao nosso redor.
Tudo bem.
E se agora formos atingidos, não perderemos uma vida.
Mas depois perdemos nosso escudo.
Está bem.
Vamos ver onde podemos encontrar essa parte em nossa declaração à direita.
Portanto.
Certo, então vamos começar aqui.
Estamos procurando o ponto em que estamos perdendo vidas e em que mudamos o estado do escudo.
Então, está dentro desta ou desta declaração?
Vamos ver este aqui.
Estamos tendo este aqui.
Esta é a primeira inicial.
Este aqui.
E aqui podemos ver.
Ok, é isso.
Já descobrimos isso porque, nessa instrução if, tomamos a decisão se perdemos
uma vida, que é esta aqui, esta linha, ou se mudamos o escudo do jogador, que é esta linha aqui.
Portanto, não é necessário procurar nessa declaração if aqui.
Portanto, isso pode ser simplesmente ignorado por nós no momento.
Tudo bem.
Agora vamos verificar essa afirmação.
Então, vamos fazer isso.
B0 é o nosso escudo.
Muito bem, então temos nosso jogador e esse jogador agora tem um escudo.
Portanto, se esse ponto -- não for igual, v a v dois é verdadeiro.
E escrevemos isso exatamente da mesma forma que dizemos.
Ou escrevemos isso como se fosse nosso escudo.
Não é igual.
Verdadeiro.
Então, entramos nessa condição.
Está bem.
Essa condição é.
Vamos verificar isso mais uma vez.
E nós o temos lá.
Está bem.
Foi esse aqui.
E esta é esta parte aqui.
Tudo bem.
É um pouco difícil pensar sobre isso.
Além disso, o cérebro está um pouco confuso.
Mas se continuarmos a fazer isso, você vai praticar e será mais rápido nisso.
Então, vamos dar uma olhada nisso.
O que temos aqui se nosso escudo não é igual?
É verdade que isso significa que não estamos tendo um escudo.
É disso que trata esta declaração.
Estamos perdendo uma linha aqui.
E isso é absolutamente correto.
Sim.
Se você fizer isso de forma diferente, se.
Bem, não, acho que isso é muito confuso.
Vamos apenas para a declaração de inadimplência.
Não tente mudar isso agora.
Portanto.
Portanto, se nosso escudo não for igual, ele é verdadeiro.
Portanto, não estamos tendo nenhum escudo.
Vamos para essa parte.
Caso contrário, entraremos nesta parte.
Uma linha abaixo dessa instrução if.
Está bem.
E essa linha está fazendo essa parte aqui.
Fluxo.
Esta linha está fazendo esta parte aqui.
Portanto, ele está redefinindo ou definindo o escudo como falso.
Está bem.
Portanto, temos nossa declaração e o que está acontecendo, e aqui sabemos tudo sobre isso agora, mesmo que
esteja um pouco confuso agora, está ficando um pouco mais confuso.
Mas pense no que eu recomendei.
Portanto, nesse caso, nosso jogador não tem escudo.
Se o jogador não tiver escudo e for atingido, ele perderá uma vida.
Agora queremos mudar isso.
Queremos mudar o fato de nosso jogador ter um escudo.
E se formos atingidos, não perderemos uma vida.
E para obter essa data, podemos simplesmente inverter essa declaração if, o que levará a se o jogador à esquerda, essa
é a declaração original, pegar um escudo.
Então, vamos fazer isso da seguinte maneira.
O jogador estará protegido.
Portanto, esta é a parte aqui referente à declaração correta.
No nosso caso, isso significaria que, se estivermos pegando um escudo, não teremos mais nenhum escudo e estaremos
vulneráveis.
Portanto, desde que não estejamos pegando um escudo, estamos seguros.
Mas acho que agora está um pouco complicado.
Portanto, se você quiser, siga a recomendação.
Caso oposto.
Então, começando com um escudo, este aqui.
Queremos começar com o escudo e perder zero vidas, se quisermos.
Se formos atingidos, teremos que inverter essa lógica aqui.
Isso significa que, em vez de não sermos iguais, estamos sendo iguais.
Mas, ainda assim, vamos pensar sobre isso.
Vamos analisar essa instrução if e ver se ela está correta.
Portanto, limpamos esse lado aqui.
Portanto, invertemos a lógica.
Isso significa que agora devemos ter o estojo com o qual o jogador começa e o escudo até que ele pegue
outro.
Mas isso não é importante.
Portanto, esse seria o nosso caso.
Nosso jogador começa com um escudo.
Vejamos.
Está bem.
Se.
O zero é esta folha de pontos.
Se esse ponto -- for igual.
Verdadeiro.
Ok, então estamos mudando isso para esta declaração.
Se -- for igual.
Em seguida, entramos nessa instrução ou nesse ramo aqui, o que significa que estamos perdendo uma vida.
Sim.
Está bem.
Isso é ruim.
Mas vamos dar uma olhada no outro lado da moeda.
Portanto, este aqui se torna falso.
Portanto, não estamos compartilhando.
É igualmente verdadeiro.
É claro que esse não é o caso.
Portanto, isso será falso em um resultado.
Esta é uma declaração.
Isso significa que vamos para essa linha aqui e isso significa que vamos terminar aqui.
Tudo bem.
Isso é confuso.
Agora tento pensar sobre isso mais uma vez, talvez duas ou três vezes.
É muito difícil.
Mas, ao praticar isso, você estará fazendo.
Você fará isso em alguns segundos nas próximas seções.
Está bem.
Então, vamos verificar isso mais uma vez.
Se não tivermos um escudo, não poderemos ser atingidos ou não.
Digamos que, se não tivermos um escudo, nosso jogador comece o jogo e não tenha um
escudo.
Se o jogador não tiver um escudo, entraremos nesse ramo aqui, o que significa que nosso escudo será
falso.
Tudo bem.
Mas isso também significa que não estamos perdendo uma vida porque não estamos entrando nesse ramo aqui.
E vamos ver como isso vai se desenrolar.
Está bem.
Então, começamos nosso jogo.
Não estamos tendo um escudo.
Se não estivermos com um escudo, acabamos nesta filial aqui.
Portanto, se formos atingidos, perderemos nosso escudo.
Muito bem, vamos voltar.
Se formos atingidos, vamos ver.
Nosso escudo ainda está nas falhas do estado.
Isso significa que ainda não temos um escudo.
Isso significa que se false for igual a true, acabaremos aqui.
Está bem.
Mas com relação à inversão, à lógica, é sim, é muito difícil, pelo menos para o meu cérebro,
seguir isso.
E se você também tiver dificuldades, escreva dessa forma, talvez um pouco mais limpa do que eu.
Mas, sim, se você escrever isso e continuar dizendo em voz alta, isso o ajudará muito.
Está bem.
Tudo bem.
Então, vamos praticar isso rapidamente.
Então, primeiro, vamos nos conectar ao nosso dispositivo.
Então, vamos obter a tela e instalar esse aplicativo aqui.
Desta vez, estou usando a versão smiley to design, mas, como já foi mencionado, ela funciona exatamente da
mesma forma que a outra, a versão Smiley Tool, mas essa tem um resultado mais sofisticado.
Portanto, estamos instalando esse aplicativo.
Tudo bem.
E depois damos uma olhada rápida neste.
Podemos ver que obtivemos um ícone muito bonito aqui.
E, se você abrir isso com cuidado, ficará absolutamente lindo.
Portanto, temos nossas vidas.
E se você clicar em "hit" e depois puder ver que perdemos um live.
E se tivermos um escudo e pudermos ver que temos um escudo aqui.
Se formos atingidos mais uma vez, perderemos nosso escudo.
E também já falamos sobre esse aqui.
Portanto, se agora formos atingidos, não teremos um escudo.
Estamos perdendo uma vida tão fácil.
Restam duas vidas.
Vamos recuperar um escudo.
Somos imunes para uma única chance.
Tudo bem, perfeito.
Vamos decodificar esse aplicativo e, em seguida, aplicar nosso patch.
Portanto, estamos usando o APK para sair e agora estamos abrindo o Smiley Directory mais uma vez com o código do Visual
Studio.
Portanto, a ferramenta da Smiley Class.
E, desta vez, eu não só confio no autor, mas desta vez estamos tendo um pouco de diversidade
em relação aos números das linhas.
Portanto, se entrarmos em hacking de aplicativos e depois em player ou smiley e habilitarmos o Java, se rolarmos a tela
para baixo, veremos que o número da linha agora é 38 e antes era 37, o código é exatamente o mesmo.
Portanto, cada instrução aqui é a mesma, mas os números de linha são diferentes.
No entanto, não nos importamos com os números das linhas.
Nós nos preocupamos apenas com essas linhas de código aqui.
Portanto, podemos simplesmente ignorá-los e continuar com nosso aplicativo.
Portanto, se analisarmos nosso aplicativo com a exclusão, eles corresponderão perfeitamente mais uma vez.
Portanto, não se distraia com números de linha diferentes.
Concentre-se em sua aplicação, em seu estado e, então, você estará pronto para ir em frente.
Muito bem.
Então, aqui temos nossa condição, if not equal, e agora estamos invertendo a lógica.
Por isso, revertemos e projetamos exaustivamente cada linha aqui.
E agora entendemos completamente essa parte aqui, o que significa que se você está invertendo a lógica, então estamos
invertendo a lógica em relação ao escudo.
Portanto, agora o que deveríamos ter é que não deveríamos começar com um escudo, mas deveríamos ser
imunes até que pegássemos um escudo.
Ok, vamos verificar isso.
Aplicamos nossa lógica.
A inversão não igual se torna igual.
E agora estamos reconstruindo esse aplicativo.
Ainda o temos aqui.
Portanto, apk para ser somali para projetar.
Tudo bem.
E agora vamos assinar este aplicativo.
E, primeiro, precisamos alinhá-lo.
Portanto, não se trata de um smiley para o sinal.
Em seguida, precisamos que nosso signatário épico assine esse aplicativo.
Altere-o como a senha.
E agora precisamos desinstalar a versão atual.
Vamos fazer isso bem rápido.
Bem, não este aqui.
É este aqui.
Tudo bem.
E agora vamos instalar nossa versão do APK.
Recupere a tela e, em seguida, vamos ver se a correção foi bem-sucedida.
Então, iniciamos esse aplicativo e agora vamos ver se podemos ver que um escudo é falso.
Portanto, tudo parece normal até que pressionamos o botão de pressionar.
Podemos ver que não estamos perdendo nenhuma vida, o que é incrível, certo?
Portanto, agora invertemos a lógica de que estamos tendo um escudo e, com base em nosso loop infinito, não estamos alterando
o estado.
Portanto, não perdemos nenhuma vida porque nosso estado de proteção não muda mais.
E sim, com base na inversão da lógica, agora estamos imunes a essa aplicação até pegarmos um escudo.
Portanto, se agora você está pegando um escudo, podemos ver uma saída visualmente maravilhosa e também podemos ver que o escudo foi definido
como verdadeiro.
Se você clicar agora no botão hit, poderemos ver que o escudo permanece ativo.
Mas estamos perdendo vidas.
Portanto, isso é exatamente o que esperávamos, e é assim que a inversão da lógica funciona.
Invertemos a lógica desse aplicativo e, ainda assim, obtemos uma grande vantagem com isso até colhermos
uma semente.
Muito bem.
No próximo, daremos uma olhada no método dois e depois no método três.
Além disso, temos vários exercícios em que você pode praticar todas essas coisas.
Está bem.
Portanto, estou ansioso para vê-lo lá.