Tudo bem, pessoal, como está indo?
Você precisa reproduzir ícones ou até mais na sua tela neste momento?
É incrível se esse for o caso.
E não se preocupe muito com isso.
Vamos dar uma olhada nesse caso juntos agora mesmo.
Portanto, vamos lá.
Tudo bem.
Portanto, aqui estamos de volta ao smartphone.
E agora vamos configurar tudo.
Primeiro, vamos pegar nosso smartphone e dar uma olhada no aplicativo.
Não este, mesmo que pareça absolutamente incrível.
E este aqui.
Este é o nosso aplicativo de embalagem espacial.
E aqui, vejamos, estamos conversando.
E este está no player.
E agora queremos ter vários jogadores em nossa palavra.
Muito bem.
Vejamos.
Por enquanto, podemos encerrar essa questão com um EPS.
Eu entendi.
Portanto, vamos fechar esse aplicativo.
Portanto, com um EPS, temos o painel de espaço, sombra x, este aqui.
Sim.
Portanto, trabalharemos com isso em um projeto do eclipse.
Portanto, vamos abrir o eclipse.
Está bem.
Portanto, este é o código de descompilação em um projeto do eclipse aqui.
E agora vamos procurar por este.
Portanto, estamos procurando criar um jogador.
Vejamos.
E vamos colocar isso na parte inferior.
Está bem.
Portanto, a tela do jogo.
Quer dizer, isso parece exatamente o que queremos ter na tela do jogo.
Temos essa fábrica de entidades para criar um jogador, que está criando um novo jogador e temos que fornecer
essa instância de palavra.
Vamos dar uma olhada nessa função de criação de player.
Ah, sim.
Estamos em eclipse, portanto não podemos clicar duas vezes.
Acho que se você estiver pressionando control e click.
Sim, então podemos ver, mantendo o botão de controle pressionado, podemos ver.
Implementação de declaração aberta.
Tipo de retorno aberto.
No nosso caso, agora, queremos abrir a implementação e, portanto, temos que liberar essa chave de controle e,
em seguida, podemos simplesmente clicar nessa chave.
Sim.
Então, aqui está.
Esta é a implementação da função create player.
Este está em uma função estática e está retornando para a entidade.
Estamos fornecendo uma instância de palavra aqui e podemos ver que também estamos criando essa função
aqui e a posição e, vejamos, com base em nosso mundo, estamos criando essa entidade mundial e agora podemos ver que
estamos adicionando todos esses sprites e todos esses valores aqui.
Então, o que precisamos fazer é examinar a memória em busca de um objeto do mundo existente.
Deve haver apenas um disponível.
Em seguida, temos que usar isso no método on choose para chamar essa função estática com nosso objeto de palavra.
Sim, é assim que podemos criar um jogador em nosso mundo.
Vamos fazer isso.
Portanto, vamos abrir os resultados no arquivo de código.
E estamos colocando isso à direita.
Portanto, podemos fechar este e salvar o arquivo.
Está bem.
Portanto, mais uma vez em Java, não execute e preciso ativar o JavaScript.
Está bem.
Em seguida, nossa função anônima e aqui estamos usando os reais para encontrar essa instância de palavra.
Ok, vamos ver essa palavra.
Mais uma vez, podemos pressionar o botão de controle e clicar neste.
Aqui, ele não está clicando, talvez apenas passando o mouse sobre ele não está clicando, apenas passando o mouse sobre este.
E também podemos abrir a declaração ou a implementação dessa declaração.
Vamos chamar a declaração.
Portanto, temos que liberar esse botão de controle agora mesmo e, em seguida, podemos clicar.
No momento, não é tão intuitivo, mas é muito útil.
Portanto, esse é o nosso objeto mundial.
Ok, estamos procurando por este.
Mas voltemos a este aqui.
Agora, vamos ver aqui.
Temos que fornecer nossos retornos de chamada.
Portanto, mantivemos essa correspondência.
Função anônima.
Você terá nossa instância de palavra.
É isso aí.
Está bem.
Agora, vamos ver.
E este é um método estático.
E esse método estático está dentro dessa fábrica de entidades de classe.
Portanto, para chamar um método estático em Java, temos que usá-lo da seguinte forma: a classe e, em seguida, simplesmente colocar
o nome do método.
É assim que podemos chamar um método estático em Java e é exatamente o mesmo no freedom.
Portanto, o que precisamos obter é a referência de classe e, em seguida, podemos simplesmente usar essa referência de classe para chamar
o nome do método.
Vamos fazer isso.
Então, vamos buscar a fábrica de entidades.
Referência de classe.
Trabalho árduo.
Muito bem, vamos fazer isso.
E isso está dentro dos serviços, DOT.
E depois temos isso aqui.
Talvez.
Vamos colocar isso mais à direita.
Podemos fazer isso?
Não.
Então, vamos manter isso em primeiro plano.
Está bem.
Assim, não estamos pulando o tempo todo.
Muito bem, aqui está ele agora.
Legal.
Agora temos essa referência de classe para chamar o método estático.
Podemos simplesmente usar isso exatamente como vimos no comentário aqui.
Portanto, o ponto de referência da classe e, em seguida, o nome do método.
Criar jogador.
E agora precisamos fornecer essa palavra à nossa instância.
Sim.
E isso criaria um novo jogador.
Quero dizer, aqui temos um valor de retorno, uma entidade, mas não estamos fazendo nada com
ela no momento.
Tudo o que queremos fazer é chamar esse método estático.
Tudo bem.
Está bem.
Vamos ver se esse aqui funciona.
Portanto, vamos remover todos esses espaços.
Está bem.
E agora também, vamos comentar isso rapidamente, pesquisando instâncias de palavras na memória.
Se encontrarmos um.
Obtendo a referência da classe de fábrica da entidade.
Não tenho certeza se escrevi isso corretamente.
Vamos fazer desta forma.
E aqui estamos chamando o método aesthetic da classe de fábrica de entidades.
Em nossa instância, como instância de palavra de parâmetro.
Está bem.
Parece bom.
Vamos tentar isso.
Novo terminal.
Vamos manter isso em primeiro plano.
E agora precisamos começar a liberar o servidor primeiro.
Então, vamos ver se ele já está em execução.
Acho que o P é o Acho que o P é o A mostra tudo.
Sim.
Portanto, agora podemos procurar gratuitamente o que não é.
Nenhum processo de gratuidade deixa de ser executado.
Portanto, dentro dos dados temporários locais, podemos iniciar este.
Este já foi iniciado.
Em seguida, um novo terminal.
E essa antecipa a recuperação da tela do nosso smartphone.
Três dias de atraso em relação ao smartphone.
É isso aí.
Tudo bem.
E agora vamos ver também.
Quero dizer, desta vez não precisamos de um AdBlock na saída para observar ou algo assim, porque podemos ver
com certeza se estamos criando um novo objeto de jogador.
Talvez.
Vamos voltar a este aqui.
Então, sim, fiquei com um pouco de preguiça nesse caso.
Desculpe-me por isso.
Vamos também finalizar com a função incompleta e completa.
Vamos imprimi-lo e terminar a digitalização e talvez também imprimir aqui quantas instâncias temos dessa palavra,
porque também podemos ter várias instâncias e, então, temos que descobrir como
lidar com essa.
Agora estamos presumindo que há apenas um disponível no momento e que isso pode nos ajudar mais tarde.
Está bem.
Eu vejo em tipo aqui.
Portanto, não tenho certeza do que está acontecendo no momento.
Aqui, vamos imprimir uma declaração de depuração.
Instância mundial encontrada.
Muito bem.
Agora salvamos isso e.
Esse jogador.
Tudo bem.
E agora podemos usar isso.
Então, vamos iniciar o aplicativo.
Este não.
Este aqui.
Está bem.
Retomamos porque adicionar esse jogador sem ter um jogo não faz absolutamente nenhum sentido.
Vamos colocar isso em primeiro plano.
Podemos clicar em iniciar.
E agora estou aplicando esse código em nosso terminal freedom aqui.
Então vamos ver.
Estou fazendo isso na proporção de 3 para 1.
Ele trava e, mais uma vez, isso é lamentável.
Portanto, isso diz respeito à nossa viagem com nosso aplicativo aqui.
Portanto, vamos tentar ver se o nosso script funciona em nossa máquina virtual; se esse for o caso, saberemos qual é a nossa
taxa.
O script funciona perfeitamente e, se não funcionar, temos que investigar o problema.
Ok, vamos fazer isso.
Portanto, a máquina virtual Java deve estar funcionando.
Vejamos, abrimos um novo terminal e agora estamos fazendo uma conexão ADB com este.
Sim.
Legal.
Vamos ver a tela.
E vamos organizar essas janelas rapidamente.
Dessa vez, foi um pouco mais fácil.
Aqui estamos tendo nosso terminal gratuito.
Aqui, estaremos jogando nosso jogo mais tarde.
E este é o nosso roteiro.
Vamos manter o terminal gratuito em primeiro plano.
Está bem.
Agora, nós os temos organizados.
Vejamos.
Iniciamos este aplicativo mais uma vez com nossa liberdade.
E, dessa vez, podemos ver que os servidores não estão funcionando gratuitamente.
Portanto, um último terminal.
A hora local dos dados do shell do ADB está iniciando essa gratuidade para o servidor.
Tudo bem.
Agora podemos iniciá-lo.
Ele deverá aparecer em alguns segundos.
É isso aí.
Retomamos o jogo.
Está bem.
Clicamos no nível oito.
Copiei o script que colei aqui e agora está em 3 para 1.
Talvez.
Talvez eu tenha que fazer isso.
Vamos criar algum espaço aqui.
Quero dizer, estamos no nível oito, então esse jogo se tornou um hype ridículo neste momento.
Então, lá vamos nós.
Está bem.
Espera-se que estejamos criando um novo objeto de jogador em 3 para 1.
Aqui está.
Agora temos dois jogadores aqui.
Incrível.
Vamos fazer isso mais uma vez.
Está bem.
Temos mais um?
Quero dizer, poderíamos procurar na memória por essa, mas posso lhe dizer que sim, estamos tendo uma.
Podemos observar isso na foto do jogador.
Portanto, ele se tornou um pouco mais rápido.
E se estivermos adicionando um novo jogador, podemos ver que esse tiro do jogador se tornará ainda mais rápido.
Quanto mais objetos estivermos criando.
Portanto, agora estamos tendo uma sessão rápida aqui.
Agora há muitas perguntas.
A primeira coisa é: se estivermos sendo atingidos, o que acontecerá?
Vejamos.
Tudo bem.
Podemos ver que o jogo acabou porque perdemos todos os objetos do jogador aqui de uma só vez.
Isso significa que estamos criando alguns objetos de jogador e essas vidas aqui agora contam.
Se todos os cinco objetos do jogador forem atingidos, estaremos perdendo todas as cinco vidas e o jogo terminará.
Isso depende totalmente do jogo em si.
Então, como ele está sendo programado ou como estamos nos conectando e interagindo com esse jogo.
Está bem.
Mas, até agora, está sendo absolutamente incrível.
Também podemos ver que há apenas uma instância mundial disponível aqui.
Portanto, estamos adicionando todos esses jogadores agora nessa instância mundial.
Ok, agora vamos voltar aos slides e fazer uma rápida recapitulação deste.
Está bem.
Então, aqui estamos de volta aos slides.
Vamos recapitular o que fizemos.
Identificamos esse método estático para criar um jogador.
Mas esse método requer um objeto existente, uma instância, essa palavra instância.
Portanto, não podemos simplesmente criar um novo.
Temos que encontrar o existente e fornecê-lo como parâmetro para criar nosso novo player.
Também em nossa tela, o que precisamos fazer é examinar a memória do aplicativo para encontrar a instância
do mundo existente.
Em seguida, temos que aplicar essa instância existente como parâmetro ao nosso método estático.
Crie um player aqui.
Isso criará um verdadeiro jogador em nosso jogo móvel aqui.
O bom desse método é que ele é estático, pois não requer um objeto.
Podemos simplesmente usar o nome da classe e, em seguida, o nome do método e fornecer a instância existente.
Isso levanta a questão: o que fazer se estivermos tendo várias instâncias?
Digamos que temos essa instância de mundo, essa instância de mundo existente, e precisamos
fornecer isso como um parâmetro para uma instância existente, para outra instância existente.
Portanto, teríamos que usar o Java para escolher duas vezes ou podemos usar uma abordagem diferente.
Muito bem, vamos falar sobre esse caso agora.
Mas, na verdade, não está relacionado à Frida.
Certo, um pouco, mas isso está mais relacionado à programação em si.
No entanto, vamos fazer isso rapidamente.
Então, digamos que temos a instância do chefe e essa instância de postagem tem o método drop item nesse
método que agora está exigindo outro objeto, esse objeto item.
Então, como podemos fazer isso?
Bem, primeiro temos que procurar essas instâncias de itens e podemos fazer isso da seguinte maneira.
À esquerda, podemos ver que estamos usando mais uma vez o Java perform e, desta vez, estamos criando um novo array.
Essa matriz será usada posteriormente.
Então, primeiro, mais uma vez, estamos usando ferramentas Java e estamos procurando instâncias de itens em nosso aplicativo.
Se encontrarmos um, nós o armazenaremos agora mesmo nessa matriz.
Assim, armazenamos o endereço desse item em nossa matriz e, por tê-los nessa matriz, podemos reutilizá-los em nosso
código livre mais tarde.
Então, digamos que temos nosso chefe aqui.
Portanto, estamos procurando essas duas instâncias aqui.
E agora, se encontrarmos um, poderemos iterar em nossa matriz, ou seja, em nossa matriz de objetos, e
reutilizar esses itens em nosso método boss, por exemplo, esse item drop.
Está bem.
Então, mais uma vez, vamos recapitular isso aqui à esquerda.
Estamos buscando essas instâncias de itens e criando uma nova matriz.
Toda vez que encontramos uma instância de item, nós a colocamos em nossa matriz, como aqui.
Agora, temos três instâncias de itens em nossa matriz.
Agora, se quisermos chamar o método de drop item do POS da instância, teremos de fornecer essas instâncias existentes,
mas já as salvamos em nossa matriz, de modo que podemos simplesmente reutilizá-las aqui e, em seguida, podemos
simplesmente fornecer uma instância existente em outro método de instância.
Muito bem.
Está bem.
Se morrermos, teremos que lidar com variáveis globais.
Mas você encontrará todas essas informações na folha de dicas.
Portanto, dê uma olhada nesse caso.
E, é claro, em caso de dúvidas, fique à vontade para me enviar uma mensagem abaixo deste vídeo.
Fico muito feliz em receber um feedback.
Muito bem.
Está bem.
Caso contrário, isso é tudo para este vídeo no momento, e estou realmente ansioso para vê-lo
no próximo.