Bem-vindo de volta.
Portanto, o último vídeo foi um pouco longo, mas sim, acho que não funciona se cortarmos certas partes desse
casaco porque precisamos entendê-lo em um buraco.
Portanto, sim, desculpe-me por ter falado tudo isso, mas espero que isso o ajude a entender esse tópico,
mesmo que demore um pouco mais.
Agora temos uma versão mais curta.
Estamos analisando o segundo método, o método de apagar, e esse é bem fácil.
Vamos ver como isso vai se desenrolar.
Portanto, temos um novo objeto aqui.
Esse é o nosso jogador.
E o jogador agora pode obter alguns itens, por exemplo, e mascarar o limite.
Ao obter esse limite mestre, o jogador recebe um upgrade de poder a partir de 100.
Caso contrário, receberemos apenas um upgrade de potência a partir de dez.
Este é o nosso código.
Agora, desta vez, queremos conseguir ter sempre essa atualização de energia sem ter esse item.
E aqui podemos fazer a mesma abordagem de antes.
Podemos simplesmente inverter a lógica disso, o que significa que sempre teremos o item, a menos que realmente busquemos
isso e, então, terminemos no caso.
Portanto, isso foi um pouco estranho.
Tarefa inteligente, mas resolvemos isso no último vídeo.
Agora fazemos uma abordagem diferente.
Simplesmente entramos nessa instrução if e, sim, apagamos essa linha apagando esse slide.
Isso é bastante ridículo.
Eu sei, porque o que há com o restante do código?
Então, o que está acontecendo aqui?
Bem, se apagarmos essa linha, teremos simplesmente um código sequencial.
Portanto, se você entrar nesse método, essa é simplesmente uma instrução normal no momento, sem ter uma condição.
E depois dessa instrução, agora há um código estranho, não é?
Portanto, isso parece muito estranho em relação à parte Java no momento, porque estamos com alguns
colchetes abertos e há edições sem um if e coisas assim.
Mas, com relação à parte sorridente, não é tão estranho assim, na verdade não, porque na maioria
das vezes estamos indo para depois de onde terminamos ou sim, pule a outra parte, esta parte aqui.
Portanto, ao apagar essa instrução if, o código não é necessariamente interrompido.
Para ser honesto, na maioria dos casos, ele funciona normalmente, apenas sem ter e condição.
E esse é um truque muito legal e também muito útil.
E é isso que você quer experimentar agora mesmo.
Então, escrevemos esse pequeno trecho de código aqui e, em seguida, simplesmente excluímos essa linha.
E, ao executar esse aplicativo mais uma vez, obtemos nosso nível de energia automaticamente, sem nenhuma
condição.
E isso é muito legal.
E também descobriremos que pulamos automaticamente esta parte aqui sem fazer nada.
Esse é apenas o código pretendido, como seria em relação à instrução if.
Ok, chega de conversa.
Vamos dar uma olhada.
Está bem.
Aqui adicionamos nossa vm ubuntu e podemos ver o código antigo.
E se você der uma olhada nesse código, ele já parece bastante ridículo.
Mas também é incrível porque podemos entender cada linha que está lá, com relação à parte
do sorriso.
Certo, mas, por enquanto, vamos pegar o exemplo dos slides.
Então, vejamos, estamos criando um novo método e nomeamos esse método.
Public void has item.
Está bem.
E fornecemos um objeto de jogador aqui.
Tudo bem.
Em seguida, criamos um novo item, que é uma tampa mestra booleana e esta é falsa.
Agora, estamos verificando se o jogador tem esse item.
Se o jogador pensou em um limite principal.
Bem, sim, deixe-me mudar isso.
Não estou gostando disso dessa forma.
Sim, assim está melhor.
Está bem.
Se tivermos esse item, aumentaremos nosso nível de energia.
Classe de bônus de nível de potência 100.
Portanto, o poder do ponto do jogador mais é igual a 100.
Caso contrário, receberemos apenas o bônus de nível de potência de dez.
Jogador de potência mais é igual a dez.
Tudo bem.
Isso parece bom agora.
Sim.
E o que estamos tentando fazer é corrigir essa linha.
Portanto, ao remover essa instrução if aqui, ela se torna uma instrução genérica.
Portanto, o resultado seria o seguinte.
Sim.
E com relação à parte do Java, ela parece estranha e também não é possível porque não tem um if estranho.
Mas em relação à parte do smiley, isso funcionará porque o smiley não tem registros e comparações
de cartões if ou ls smiley e não se importa com esse OC.
Muito bem.
Por isso, estou muito animado com a aparência.
Então, vamos criar esse aplicativo.
Vejamos.
Devemos testar isso?
Acho que devemos testar isso.
Portanto.
Opa, desculpe.
Vamos chamar este aqui.
Sim.
E, em vez de sermos atingidos, agora estamos usando nosso método aqui que tem um item.
Portanto, também precisamos fornecer um objeto de jogador.
Isso agora é um pouco ridículo, mas tudo bem, está funcionando dessa forma.
Tudo bem?
E agora imprimimos nossa energia.
Está bem?
Sim.
Agora vamos criar esse aplicativo.
E não se preocupe, eu lhe fornecerei esse aplicativo.
É claro, como sempre, na seção aqui.
Portanto, você não precisa codificá-lo por conta própria.
Vejamos.
Está bem.
Estamos instalando esse novo aplicativo muito rapidamente.
Em seguida, verificamos se está funcionando e depois damos uma olhada na parte do sorriso.
Portanto, já instalado.
Ops.
Aqui está.
Veja nossa cópia.
Tudo bem.
Sorridente também.
Vejamos.
Olá.
Você me deixa com poder 20.
Está bem.
Parece bom, eu acho.
Vejamos.
No início, tínhamos o Power ten e agora estamos recebendo um bônus de dez.
Se você fizer isso mais uma vez, teremos 30.
Sim.
Está bem.
E assim por diante.
Você vê uma matemática complicada por trás disso.
E agora, agora, finalmente terminamos ou atingimos o mesmo nível de poder com nosso bônus.
Isso me tomou muito tempo.
Quero receber isso imediatamente.
Vamos dar uma olhada nesse código Mali.
Portanto, vamos encerrar essa depuração.
Na parte de trás, estamos abrindo todo o diretório aqui com o código do Wizard Studio.
Está bem.
Aqui está.
Mudamos para Java.
Sim.
Na camada superior do arquivo de smiley.
E vamos ver, ser atingido.
Não se trata de ser atingido.
Também não é possível verificar a pontuação máxima de todas as versões desse arquivo.
Portanto, basta fechar este aqui.
Não salve.
E temos muitas outras janelas aqui.
Mas agora vamos ver.
Verificação do construtor Java.
Pontuação alta, ser atingido.
Menos itens.
Aqui está.
Vamos usar a mesa digitalizadora e descobrir como isso funciona e o que acontece se simplesmente
removermos esse if.
Linha ali.
Vamos lá.
Tudo bem.
Estou com minha mesa digitalizadora lá fora.
Vamos lá.
Portanto, nosso método tem um item e, desta vez, tento escrever um item super limpo.
Vejamos.
Portanto, esse método tem um item.
É lindo.
Está bem.
Temos um objeto ou um parâmetro que é o player.
Portanto, este é o P one e estamos tendo esse jogador.
Tudo bem.
Jogador.
Está bem.
E estamos voltando brancos.
Parece bom.
Em seguida, temos apenas um registro local lá.
Portanto, esse pode ser um suporte muito capaz.
Não sabemos.
Está bem.
Depois, temos essa linha aqui para sabermos o que é essa.
Nós sabemos o que é isso.
Você sabe o que é isso.
E também sabemos o que é esse.
Mas temos que ler primeiro.
Recebo um booleano.
Portanto, estamos buscando em nosso parâmetro de jogador e campo de instância, ou seja, sim.
Esse campo aqui deve aceitar o tipo booleano.
E colocamos isso em v zero.
Portanto, zero é agora jogador.
Essa tampa principal.
Do tipo bullion.
Então, temos nossa condição F.
Sabe o que estamos fazendo agora?
Sim, nós o lemos em voz alta.
Então, vamos ver se zero é igual a zero.
Saltamos para essa condição.
Se zero for igual a zero, saltamos para essa condição.
E este é o salto para baixo até este.
Vamos ver o que temos aqui.
O zero é o nosso limite principal de jogadores.
E isso significa que se o nosso limite principal de jogadores for falso.
Portanto, se este aqui for falso, então teremos falso igual a igual a falso.
Em seguida, entramos nesta declaração.
Está bem.
O que fazemos aqui?
Temos um I get, então pegamos nosso azul mais uma vez.
Agora, estamos tirando nossa potência do tipo, número inteiro do nosso parâmetro.
E armazenamos isso em V zero.
Tudo bem.
Estamos substituindo o V zero neste momento, portanto, vamos colocar um sinal de alerta aqui.
Muito bem.
Nós zero é agora.
Brincar, não poder.
Escrito em excesso.
Está bem.
Em seguida, estamos adicionando o int 0xa, que é dez, ou seja, o que foi dito.
Portanto, não estamos adicionando mais de dez.
Portanto, não estamos tendo nosso nível de superbônus.
Adicionamos isso a zero e voltamos ao V zero.
Portanto, temos zero zero mais dez.
Isso significa que estamos tendo nosso poder de jogador.
Escrevo isso um pouco mais curto para que o poder do jogador limpo mais seja igual a dez.
Desculpe, mas não é assim que funciona.
Mais é igual a dez.
Aqui está.
Tudo bem.
E, em seguida, estamos colocando ou obtendo esse objeto, desculpe, esse registro e colocando-o
de volta nesse objeto p em nosso jogo de poder
de ponto de jogador sobre poder é depois ser zero e você pode ver esse padrão mais uma vez.
Então, sim, continue praticando o smiley e isso será ainda mais fácil no futuro.
Tudo bem.
E o que vem a seguir?
Nossa linha e rótulo de destino que podem ser ignorados.
E então estamos retornando.
Retorno.
É isso aí.
Ah, isso é.
Deixo como está.
Está bem.
Você pode ver que está ficando um pouco mais limpo, eu acho.
E sim, isso não era mais tão difícil.
Assim somos nós.
Estamos praticando muito isso no momento.
Ok, talvez eu precise praticar ali, mas você sabe que 3 para 1.
Ok, então temos nossa declaração verdadeira aqui.
Vamos recapitular isso rapidamente em nossas mentes para que saibamos o que está acontecendo.
Se estivermos fazendo nossa declaração verdadeira aqui, não receberemos nosso bônus.
Portanto, verdade significa que não há bônus.
Isso significa que as falhas devem acabar aqui, dando-nos o bônus.
Vamos limpar isso rapidamente e dar uma olhada.
E assim por diante.
Está bem.
Estamos nessa fila.
Temos a declaração verdadeira já feita.
Agora estamos dando uma olhada na declaração falsa, o que significa que estamos diretamente abaixo dela.
Está bem.
Eu recebo.
Portanto, estamos obtendo o poder do jogador.
Poder do jogador e movê-lo para o OC zero.
Vamos escrever isso aqui também.
Oh, espero que este espaço seja suficiente.
Vejamos.
Eu zero agora é igual ao poder do ponto do jogador.
Está bem.
Em seguida, estamos adicionando esse valor aqui e vamos fazer as contas.
Estamos tendo quatro mais seis vezes 16.
100.
Trapaceei um pouco, mas é 100.
Então, vamos fingir que resolvemos isso aqui.
Está bem.
Em seguida, estamos adicionando esse valor ao zero e armazenando-o novamente no zero.
Isso significa que estamos tendo o equivalente a isso, mas com nosso novo nível de poder.
Portanto, zeramos mais 0x64, o que significa que ainda não há espaço mais 100.
Aqui está.
Está bem.
E então estamos colocando-o de volta em P1.
Portanto, o poder do ponto do jogador.
Aqui está.
Poder do jogador.
Isso é igual a V zero.
Agora é a parte importante.
Agora vamos pular para o nosso go to aqui.
Portanto, nosso rótulo preferido é este.
Portanto, estamos indo diretamente para isso e pulando todo esse código aqui.
Então, depois do que retornamos, esta é a nossa declaração final.
Está bem.
Vamos limpar isso rapidamente e depois vamos verificar.
Muito bem.
Vamos dar uma olhada.
Está bem.
Se estivermos tendo uma falha aqui, não receberemos nossa energia.
Com ou sem bônus, o grande bônus.
É muito difícil escrever nessa direção, mas acho que funciona.
E aqui estamos nós com o nosso grande bônus.
Está bem.
Talvez eu queira demais.
Aqui está.
Então vamos ver.
Estamos nessa declaração "se" aqui.
E o que queremos fazer é corrigir isso da seguinte maneira.
Fazemos nossa jogada de QI 200 e simplesmente apagamos essa linha.
Sim.
Está bem.
Em seguida, temos nosso código.
Vejamos.
Temos um código.
Estamos colocando nossa tampa principal do tipo booleano em V0.
Portanto, nessa linha aqui, temos v zero.
Portanto, estamos nessa linha em que o zero é igual ao limite principal do ponto do jogador.
Tudo bem.
E não temos nossa instrução if aqui porque, sim, fizemos nosso jogo de 200 IQ e simplesmente a removemos
do código do smiley.
Em seguida, entramos diretamente nesta linha, o que é bom para o que estamos fazendo aqui.
Vamos direto para essa parte.
Para a parte aqui.
Portanto, essa linha significa que estamos colocando a potência do ponto do jogador em v zero.
Portanto, estamos substituindo o último que zeramos como poder de ponto do jogador.
Oh.
Ainda errado.
Desculpe.
Jogue o poder dos pontos.
E então passamos para o código.
Você já tem isso aqui.
Portanto, agora este é o nosso código.
E por que não temos essa estranha declaração sem um if agora?
Porque se você der uma olhada.
Portanto, eu já estraguei muito tudo.
Mas acho que ainda podemos descobrir isso.
Portanto, esta linha.
Essa é a linha.
E então estamos tendo essa linha.
Tudo bem, então vamos ter essa linha.
Tudo bem.
E agora vem a parte importante.
O Smiley não tem uma declaração adicionada.
Smiley recebeu instruções de trunfo de ramo e estamos tendo uma instrução de salto aqui.
E essa e essa instrução de salto nos tiram dessa função aqui, o que significa que estamos pulando essa parte
e é como se tivéssemos uma instrução adicionada sem um F ali.
E é assim que o Smiley ainda pode funcionar se removermos uma instrução if nessa linha.
É realmente incrível, não é?
E, ao fazer isso, simplesmente obtemos nosso poder sem fazer nada.
E é isso que queremos ter.
Não queremos nos esforçar nesse jogo e queremos tirar o máximo proveito disso, nem que seja
um pouco mais.
Muito bem, vamos corrigir esse aplicativo e ver como ele funciona.
Portanto, vamos voltar ao ponto principal.
VM Ok, aqui estamos de volta à VM do Ubuntu e o que queremos fazer é a nossa análise.
Sabemos que ele está diretamente em nosso caminho.
Então, apertamos esse botão e pronto.
Foi demais!
Foi muito difícil.
Mas, pelo menos, finalmente conseguimos isso.
Ok, então vamos salvar isso.
A propósito, não temos ou ainda não temos essas linhas básicas ou novas, podemos simplesmente deixar o código
como está, mas não custa nada fazer isso até que você estrague tudo.
Mas sim, vou lhe mostrar rapidamente.
Portanto, ter essas novas linhas aqui não é problema.
Mas qual é o problema?
É claro que, se você fizer algo assim, isso será um problema.
Mas acho que isso se explica por si só.
Está bem.
Vamos reconstruir esse aplicativo novamente.
Uma semana para depurar o aplicativo.
Enquanto isso, estou recebendo
a tela do Android.
Essa é a nossa versão antiga aqui.
Sim.
Está bem.
Em seguida, temos nosso arquivo de destino.
Nós nos alinhamos com o zíper.
Ah, essa é a parte errada.
Portanto, a tirolesa dash v4 na saída traseira.
Está bem.
Então assinamos isso.
Mudá-lo?
Sim.
Está bem.
E então instalamos isso.
Ah, sim.
Ao executar ou iniciar esse aplicativo pelo Android Studio, temos um certificado diferente, portanto, precisamos
desinstalá-lo primeiro.
ADB Uninstall Come App Hacking Smiley Tool.
Agora podemos instalá-lo novamente.
Ops.
Aqui está.
Vamos voltar ao nosso casaco.
Então vamos ver.
Estamos tendo agora um nível de energia a partir do que temos?
Após atingir o padrão, deverá ser dez mais 100.
Certo.
Vejamos.
Aqui está.
Temos 110.
E, ao entrar no Watson novamente, chegamos ao valor.
É claro que sim.
Porque sim.
Recebemos instruções simples que aumentam nosso nível de potência e esse padrão é muito útil.
É realmente fácil se entendermos o código do smiley e se isso for possível, porque se você o tiver
ao contrário, não será tão fácil.
Mas o que também podemos fazer, por exemplo, é abrir esse código mais uma vez.
Está bem.
Também podemos excluir todo o impacto negativo deste ou, digamos, a menor quantidade aqui.
Portanto, podemos simplesmente acessar essa opção e excluí-la completamente.
Mas é preciso ter cuidado, pois se estivermos preenchendo registros que serão usados posteriormente, eles não serão inicializados
e nós seremos levantados ou o aplicativo apresentará alguns erros.
Portanto, a exclusão de partes lógicas não é realmente recomendada.
Se você fizer a engenharia reversa dessa parte e descobrir que, por exemplo, esta é apenas esta
parte aqui, podemos simplesmente excluí-la.
Portanto, o que temos agora é o seguinte.
Temos este aqui.
Mas não aqui.
Excluímos essa parte.
Também excluímos este.
E aqui temos o oposto desse.
Então essa é a declaração do anúncio?
Sim.
Esta é a aparência do código de correção no momento.
E o que também podemos fazer, é claro, se dermos uma olhada nisso, aumentaremos nosso poder de jogador aqui
e não precisaremos dessa parte.
Em seguida, também podemos excluir essa parte para que apenas esta, por exemplo, permaneça em nossa função.
Portanto, também podemos entrar nisso e dizer: "Ok, podemos excluir essa parte aqui".
Sim, isso também deve funcionar.
Vamos resolver isso.
Eu o salvei.
Depois, voltamos e reproduzimos esse aplicativo.
E vamos fazer a abordagem limpa.
Portanto.
Qualquer desinstalação - smiley de hacking de aplicativo para instalação do ADB.
Está bem.
Portanto, agora temos esse código Java que é simplesmente uma linha que aumenta nossa potência em 100.
E podemos ver, espero que você possa ver, que o aplicativo, sim, ainda funciona.
Portanto, apenas excluímos o código que não queremos ter lá.
E é isso que podemos fazer com esse código de sorriso.
Podemos simplesmente corrigir o que quisermos, a menos que façamos algo errado.
Mas também podemos corrigir esse caminho.
Por exemplo, se estivermos usando variáveis necessárias, poderemos configurá-las novamente depois, mas faremos
isso no capítulo seguinte.
É apenas um.
Sim.
Uma espécie de prévia do que faremos mais tarde.
Está bem.
Por enquanto.
Sim.
A remoção das linhas if ou simplesmente uma instrução if funciona e vamos fazer isso.
Vamos abrir com a exclusão de sombras e, em seguida, faremos a comparação rápida de sorrisos mais uma vez.
Então, veja como é a nossa função de patch.
Portanto, ele é nosso jogador.
E podemos ver este aqui.
Sim.
Ainda verificamos se esse booleano está definido aqui, mas não o estamos mais usando.
Assim, obtemos a inicialização desse conjunto.
Então, atribuímos esse estado booleano ali, mas não vamos mais usar essa variável, portanto,
ela fica ali.
E depois temos o nosso jogador Total Power Plus 100.
Mas o que eu queria mostrar era o seguinte.
Então, voltamos ao Visual Studio.
Sim.
Portanto, fechamos este aberto e mais uma vez.
E sim, esse é agora o estado do patch.
Assim, podemos ver que removemos a instrução if.
Esta é a nossa atribuição, nosso conjunto de variáveis e nosso código de sombra aqui.
E então temos nosso poder de jogador aqui, que é aumentado em 100 e então saltamos.
É isso aí.
Está bem.
Para recapitular um pouco, vimos que podemos corrigir as instruções if simplesmente removendo a própria
instrução if.
Isso significa que nossa próxima linha terá uma parte de código simplesmente sequencial.
Portanto, o código do programa continua sem ter mais essa condição.
Mas, na maioria das vezes, não quebramos o código porque, em nossa instrução if, já existe uma saída
para isso.
Portanto, há um retorno ou, pelo menos, uma instrução de salto já inserida ali.
Isso é como ter ou sempre atender à condição if, se simplesmente removermos essa parte aqui.
OC E esse truque é muito útil e é apenas um dos três que eu gostaria de mostrar a vocês aqui, portanto,
esse truque pode ser muito útil.
Além disso, não apenas com relação a essas declarações, podemos usar isso para todas as instruções.
Além disso, se tivermos algum código de que não gostamos, podemos tentar removê-lo, mas temos que dar
uma olhada acima e abaixo para ver se o código ainda funciona.
Portanto, se tivermos algum registro inicializado lá com determinados valores que serão necessários mais tarde, teremos que
corrigir isso, mas aprenderemos sobre isso.
Está bem.
Portanto, sim, remover o código de sorriso também é tão válido quanto corrigir linhas de sorriso.
Está bem.
Tudo bem.
E na próxima, vamos dar uma olhada no abuso das instruções de Trump.
E este é o último método de correção referente às instruções if de minha parte.
É claro que há muitos outros, mas com esses três, podemos alcançar tudo o que queremos.
Tudo bem.
Então, vejo você lá.