Bem-vindos de volta, pessoal.
Espero que você tenha se divertido muito.
Agora estamos dando uma olhada nisso juntos.
Portanto, se você não quiser receber nenhum spoiler.
Sim, pule este vídeo e passe para o próximo.
Essa é apenas a solução para conectar todos esses métodos.
Por exemplo, tornar o jogador invisível, invencível, fazer chover moedas, coisas desse tipo.
Tudo bem.
Muito bem, pessoal.
Portanto, terminei de gravar este vídeo agora mesmo.
E, sim, isso foi muito divertido, mas o vídeo ficou muito longo.
Então, deixe-me apresentar o que está acontecendo aqui para que você possa avançar rapidamente ou pular diretamente
para um ponto interessante.
Portanto, a primeira parte é sobre a manipulação da pontuação máxima.
E essa foi um pouco complicada.
Quero dizer, temos algumas abordagens fáceis que não são absolutamente nenhum problema.
Mas também quero atualizar o conhecimento existente e isso foi um pouco complicado.
Atendemos a algumas condições em que esses valores foram substituídos mais uma vez, e essa parte ficou um pouco
mais longa, mas acho que você aprenderá muitas coisas nela.
Portanto, eu recomendaria assisti-lo depois.
Vamos nos apressar em todas as outras coisas, então manipularemos todas essas outras classes e, por exemplo,
tornaremos o jogador invencível, invisível.
Vamos nos livrar desse estado de bloqueio e muito mais.
Também fornecerei alguns comentários abaixo do vídeo para que você possa acessar diretamente a seção
de seu interesse.
Manterei todos eles neste vídeo aqui, pois não quero dividi-los para criar seis ou
sete vídeos adicionais.
Está bem.
E se você já estiver familiarizado com a liberdade, talvez queira pular este vídeo inteiro, porque este vídeo
aqui pode não fornecer algumas informações adicionais para as pessoas que já estão familiarizadas com a liberdade.
Portanto, você pode passar facilmente para a próxima seção.
Você não está perdendo nada agora.
Tudo bem.
Está bem.
Então, por enquanto, vamos nos divertir um pouco.
E, ainda assim, você pode se recostar e simplesmente assistir a esse vídeo, talvez fazendo outras coisas.
Portanto, vamos lá.
Tudo bem.
Então, aqui estamos de volta à VM do Ubuntu e já vimos uma cópia de tela obscura x legal e talvez vários outros
aplicativos Java possam interferir na memória existente.
Portanto, podemos ficar sem memória e teremos alguns problemas.
Portanto, agora estamos adotando uma abordagem diferente.
Pegaremos esse aplicativo, o descompilaremos e carregaremos esse projeto no Eclipse.
Isso é muito mais eficiente em termos de recursos, mesmo que não pareça, mas com certeza
é.
E, ao fazer isso, podemos manter todo o resto aberto.
Tudo bem.
Portanto, vamos dar uma olhada nesse caso.
Dentro dos aplicativos, temos aqui nosso aplicativo de planejamento espacial e este aqui.
Agora estamos copiando isso e criando um novo diretório.
Então, oh, aqui podemos ver que já fizemos isso no passado com você.
No entanto, vamos fazer isso mais uma vez.
Portanto, excluímos este aqui e estamos criando um novo e o espaço ping underscore shade.
Tudo bem.
Agora estamos abrindo um novo terminal e usando a linha de comando do comércio X e esta aqui com o parâmetro
de ajuda, talvez.
Está bem.
Então, o que precisamos fazer?
Precisamos oferecer algumas opções.
Acho que esse é o único diretório de saída e, em seguida, o OC do arquivo de entrada.
Portanto, é um arquivo de entrada de opções.
Isso significa que estamos usando o DX como nosso arquivo de entrada e acho que temos que fornecer o arquivo de saída depois.
Portanto, isso deve funcionar agora mesmo.
Vejamos.
Pelo menos o programa está fazendo alguma coisa.
E vamos verificar se isso está correto.
Sim.
Portanto, aqui você pode ver que estamos criando um novo diretório de saída e que ele contém todo o código de descompilação.
Aqui estão os recursos e aqui estão as fontes.
Agora estamos interessados apenas nas fontes porque não nos importamos com esses arquivos de recursos aqui.
E, por exemplo, essas imagens e coisas do gênero.
Também podemos ver o acabamento com erros.
Segundo, observamos todo esse processo de compilação do DE com X em um vídeo anterior.
Assim, vimos como podemos aplicar determinados recursos para brincar com a ofuscação ou, por exemplo.
Sim, para imprimir algum código.
Este aqui.
Se X não estiver conseguindo descompilar um determinado método, ele será impresso.
Caso não tenha visto esse vídeo e ele lhe pareça interessante, dê uma olhada no
vídeo sombrio, que está, creio eu, em ferramentas.
Sim, deveria haver esse vídeo agora mesmo.
Está bem.
De volta a este aqui.
Agora, estamos criando um novo projeto do Eclipse e, em seguida, carregando os códigos-fonte e este em nosso
projeto.
Muito bem, vamos fazer isso.
Ah, não.
Terminal.
Acho que o Eclipse pode ser iniciado aqui e pronto.
Aqui está, e podemos ver que a última vez que brincamos com o Eclipse foi em relação ao pinup
do certificado.
Portanto, este aqui pode ser simplesmente excluído.
Sim.
Acho que isso não é mais necessário.
Está bem.
Agora estamos criando um novo projeto Java.
O nome do projeto é nosso aplicativo de ping espacial.
O restante será definido como padrão.
Esse é o nome do modelo.
E aqui temos nossas fontes.
Podemos excluir esse aqui agora mesmo.
Isso não é mais necessário e agora estamos pegando nossos códigos-fonte e simplesmente arrastando-os para esse
projeto recém-criado.
Copiar arquivos e pastas.
E isso pode demorar um pouco.
Vejamos.
Isso é muito rápido.
Não leva muito tempo.
Agora, todas essas fontes serão criadas, e poderemos usar a pesquisa e o trabalho neste projeto aqui
para fazer a engenharia reversa desse aplicativo e encontrar tudo o que nos interessa.
Tudo bem.
Ele já foi carregado.
Legal.
Então, vamos voltar à nossa lista e ver o que temos que fazer.
Portanto, esta é a nossa lista.
As vidas já foram feitas.
Agora vamos dar uma olhada na escola de ensino médio.
Portanto, simplesmente pesquisamos essa única pesquisa.
Estamos pesquisando aqui e não estamos pesquisando para a fixação de certificados.
Estamos buscando uma escola de ensino médio.
Vamos ver esses parâmetros.
Sim, espaço de trabalho.
Está bem.
Certifique-se de que a diferenciação de maiúsculas e minúsculas não esteja sendo verificada, pois, caso contrário, se
o ensino médio for escrito de forma diferente, por exemplo, desta ou desta maneira, ele não será encontrado.
Muito bem, apertamos o botão de pesquisa e temos vários resultados.
Também podemos praticar essa janela do resort aqui fora.
Assim, fica um pouco mais fácil de ver, e eu gosto de mantê-lo no barco dessa forma.
E agora podemos simplesmente clicar duas vezes nesse aqui.
Portanto, com um perfil, temos isso no ensino médio.
Vejamos.
Isso parece absolutamente promissor.
Portanto, temos uma pontuação alta de uma polegada igual a nenhuma.
Depois, temos o último nível jogado.
Temos funções.
Obter a pontuação máxima definida.
Pontuação máxima.
Desculpe, eu mantenho o mouse no conjunto certo se houver uma nova pontuação alta.
Portanto, se tivermos superado a pontuação máxima, obteremos o último nível jogado e definiremos o último nível jogado.
Portanto, parece que é difícil encontrar uma opção em que não possamos modificar essa pontuação alta aqui.
Em nosso caso, vimos no último vídeo como manipular esse campo.
Agora vamos usar a abordagem de instância.
Portanto, estamos usando esse método e definimos a pontuação máxima aqui e, em seguida, estamos fornecendo um novo valor
como parâmetro.
E aqui, para alterar essa pontuação alta desse campo de instância, temos uma abordagem diferente.
E, ao fazer isso repetidamente, você terá, em resumo, todas as possibilidades ou talvez quase todas
as possibilidades de conectar determinados métodos ou instâncias do Android aqui.
Muito bem, agora vamos fazer isso.
Portanto, estamos abrindo esse código de estúdio antigo.
E estamos criando uma nova luta.
Em seguida, passamos para o JavaScript.
E, dessa vez, salvamos diretamente o arquivo.
Portanto, em nosso espaço retratado x, estamos criando um novo diretório.
Então, simplesmente clicamos nesse ícone aqui e nomeamos essa liberdade e a renomeamos como Now Hook High School.
Sim.
OC colocou isso à esquerda e nosso eclipse à direita.
Pronto, agora todas as janelas estão organizadas.
Legal.
Ao dar uma olhada nessa classe de perfil, é difícil encontrar uma maneira que não funcione.
Portanto, aqui temos todas essas oportunidades disponíveis para nós.
Por exemplo, temos essa instância Field High School, portanto, poderíamos examinar a memória do aplicativo,
identificando uma instância existente e alterando esse campo de pontuação alta aqui.
Também podemos usar essa instância para chamar o método.
Por exemplo, este aqui dizia "High score".
E, por último, mas não menos importante, há uma abordagem em que, onde não olhamos por um tempo, conectamos um
método e fornecemos uma nova implementação.
E foi aqui que começamos com três aqui, e este também deve funcionar.
Portanto, se olharmos, por exemplo, para essa função de definir a pontuação máxima, poderemos fornecer uma nova pontuação
máxima.
Portanto, todas essas três abordagens devem funcionar e nós as analisamos.
No momento, não estamos fazendo isso para todos, mas aqui, acho que é bom ver uma recapitulação do que
aprendemos e das possibilidades que temos.
Tudo bem.
Está bem.
Portanto, se você der uma olhada no nosso aplicativo, começaremos com a instância.
Então, primeiro, talvez, talvez, vamos reinstalar esse aplicativo para ter certeza de que estamos trabalhando
com o original.
Está bem.
Painel de instalação do ADB.
Ah, isso substituirá a versão existente.
E agora vamos ver isso na tela.
Podemos colocar isso à esquerda?
E agora vamos iniciar esse aplicativo.
Está bem.
Então, aqui estamos com nosso aplicativo de ping espacial.
Se clicarmos em Iniciar, veremos que obtivemos uma pontuação alta de 750.
Se estivermos atirando assim, você poderá ver que nossa pontuação aumenta até atingirmos uma pontuação
maior do que esta aqui, e então teremos uma nova pontuação alta.
Tudo bem.
Nossa abordagem no momento é a seguinte: talvez não sejamos atingidos.
Portanto, vamos criar um espaço aqui.
Aqui está.
Está bem.
Agora, a abordagem é a seguinte.
Estamos examinando a memória do aplicativo e tentando encontrar essa instância de perfil.
Acho que deve haver apenas um disponível, a menos que tenhamos vários jogadores com várias pontuações altas.
Mas esse não deveria ser o caso aqui.
Aqui temos um jogador e uma pontuação máxima.
Portanto, devemos ter uma instância de perfil.
Tudo bem.
Se você encontrou essa instância de perfil, poderíamos simplesmente adotar a abordagem de mudar o campo
dessa instância para este aqui, com uma pontuação alta.
Mas isso é algo que fizemos no último vídeo.
Por isso, desta vez, fizemos um pouco diferente para que você veja mais opções.
Neste momento, estamos usando o método de instância, portanto, estamos pegando nossa instância e, em seguida, chamando
ativamente o método set high score nessa instância e, como parâmetro, estamos fornecendo agora nosso novo valor de
high score.
Isso deve funcionar agora mesmo e, portanto, vamos dar uma olhada, vamos começar a codificar isso em liberdade.
Está bem?
Portanto, a primeira coisa que precisamos fazer é dizer à Frieda para anexar ao CBM, porque este
aqui ainda é um código Java.
Portanto, precisamos de nossa conexão com a máquina virtual Java.
Podemos fazer isso usando o Java plot perform como parâmetro.
Estamos fornecendo nossa função anônima e esta é agora nossa seção de código.
Se você quiser verificar a memória de um aplicativo em relação a uma instância, será necessário usar o Java dot choose.
Portanto, estou procurando na memória uma instância de perfil existente e o Java Dot faz loops no Java dot para escolher o primeiro parâmetro.
Esse é o nome da nossa classe ou a referência da classe e o segundo é o nosso retorno de chamada ou esses retornos de chamada.
Nesse caso, OC é a referência da classe.
E esta é a nossa classe de perfil aqui, porque queremos encontrar todas as instâncias de perfil.
Essa é a nossa referência.
Então, pegamos esse nome de pacote,
que não é uma string.
Portanto, o nome do pacote é o ponto e, em seguida, o nome da classe.
Com relação às callbacks, vamos adicionar este s aqui.
Certo, então o que faço é clicar duas vezes nisso e fornecer essas chaves.
Agora, pressiono Enter e não bagunço todos esses colchetes aqui.
Então, agora temos dois retornos de chamada.
Temos o retorno de chamada incomparável.
Se uma instância tiver sido encontrada e tivermos outro retorno de chamada, o retorno de chamada completo, se a varredura da
memória tiver sido concluída.
Certo, o retorno de chamada não correspondido.
Precisamos fornecer uma nova função anônima, e essa função agora tem a instância como parâmetro.
Depois disso, estamos definindo uma vírgula porque é assim que esses dois retornos de chamada estão sendo conectados.
E aqui não estamos fornecendo nosso próprio retorno de chamada completo, também com uma função anônima, mas dessa
vez sem parâmetro.
Och na ONU completa.
Podemos simplesmente escrever que a varredura da memória foi concluída.
Portanto, estamos imprimindo essa instrução de depuração.
E a varredura da memória em relação às instâncias de perfil foi concluída.
Então, terminamos a parte completa e agora vamos dar uma olhada na função sem correspondência.
Então, aqui estamos nós, recuperando nossa instância.
O que queremos fazer?
Queremos pegar essa instância e chamar ativamente esse método.
Está bem.
E podemos fazer isso simplesmente usando nossa instância.
Também podemos renomear isso, acho que assim fica um pouco mais fácil.
Então, vamos renomear isso para perfil, por exemplo.
Está bem.
Agora podemos usar profile, dot set, high score e podemos definir uma nova pontuação máxima.
E este, por exemplo.
Tudo bem.
Temos que permanecer no valor inteiro porque, caso contrário, criaremos um estouro de número inteiro.
Está bem.
Portanto, este é o roteiro em poucas palavras.
Mas, para ser sincero, não gosto tanto dele.
Por exemplo, temos esse erro de digitação aqui, mas esse não era o ponto sobre o qual eu estava falando.
Gosto de observar o que está acontecendo, portanto, vamos também adicionar algumas saídas de depuração adicionais.
Por exemplo, aqui, vamos imprimir que uma instância foi encontrada.
Instância ou vamos chamá-la de correta.
Foi encontrada uma instância de perfil.
Então, estamos fornecendo nosso perfil aqui.
Esse é o exemplo.
Talvez.
Vamos escrever isso aqui também.
Portanto, nosso parâmetro é a instância que foi encontrada e também imprime o valor real ou o valor
atual.
Portanto, no momento, a pontuação máxima é.
E agora vamos ver.
No perfil.
Ponto.
Vamos chamar esse método.
Basta obter a pontuação máxima.
Obtenha uma pontuação alta.
Sim.
Está bem.
E este aqui?
Sim.
Ele está retornando um número inteiro.
E com relação ao tipo, isso deve funcionar.
E agora estamos definindo essa pontuação alta como esse valor.
Agora temos um pouco mais de uma saída de depuração para que possamos ver se ela é acionada ou não.
E também podemos ver alguns valores aqui.
Tudo bem, perfeito.
Agora, vamos iniciar nosso servidor freedom em nosso smartphone e nos conectar a esse processo.
Então, primeiro, estamos nos conectando ao nosso smartphone.
Em seguida, obtemos privilégios de root e iniciamos nosso servidor gratuito.
Portanto, temos que mudar para os dados temporários locais e começar por aqui.
Tudo bem.
Grátis.
O servidor está sendo executado em segundo plano.
Agora vamos voltar ao smartphone.
Aqui está.
E agora vamos também começar esse aplicativo com liberdade.
Portanto, podemos usar um problema de dados livres e, em seguida, o nome do pacote como espaço de lixo.
Acho que esse era o nome do pacote.
Se você quiser iniciar esse aplicativo com o leitor, será necessário adicionar F para forçar essa inicialização.
E também não queremos aplicar diretamente o nosso patch porque, se estivermos aplicando o patch diretamente, talvez
possamos fazer isso.
É assim que acontece.
Assim, você pode ver o que está acontecendo.
Portanto, agora o aplicativo está sendo iniciado pela Frieda, mas foi pausado.
Portanto, temos uma tela preta.
Vamos manter isso em primeiro plano.
E agora vamos fazer isso.
E aqui podemos ver que nada aconteceu.
E o motivo disso é que nenhuma instância foi encontrada no momento porque o aplicativo não foi
iniciado.
Mas isso não é problema algum.
Eles podem simplesmente retomar esse aplicativo e, em seguida, podemos aplicar nosso script mais uma vez nesse estágio agora,
talvez eu possa organizar essas janelas rapidamente.
Então, acho que agora está um pouco melhor.
Portanto, também neste estágio, podemos ver que a varredura de mensagens da memória em relação às instâncias
de perfil foi concluída se estivermos executando nosso script novamente.
Podemos ver que o argumento não corresponde a nenhuma das sobrecargas.
INT oh.
E vejamos, já tivemos incidentes de perfil nesse estado.
Oh, isso é incrível.
Portanto, o aplicativo ainda não foi iniciado no momento.
Mas temos isso, temos essa instância e podemos ver que temos um método de sobrecarga.
Portanto, defina a pontuação máxima.
Vejamos.
Pode, disse o ensino médio.
Temos apenas uma escola de ensino médio fixa lá e estamos chamando-a de aqui.
Está bem.
Então, vamos ver essa seta.
Isso significa que não estamos tendo um fim de sobrecarga lá dentro.
E esse pode ser o caso se esse valor tiver sido escolhido para travar.
Então, vejamos.
Temos três.
Três.
Sim, podemos estar fora desse intervalo de valores inteiros e, portanto, ele pode não ser reconhecido como um valor
inteiro e, por isso, estamos recebendo esse erro de sobrecarga.
Então, vamos diminuir um pouco esse valor.
Fui um pouco longe demais nesse caso.
Ok, vamos tentar mais uma vez.
E aqui podemos ver que agora o aplicativo trava.
E é exatamente sobre isso que eu estava falando no final do último vídeo.
Se estivermos recebendo esse erro aqui, podemos ver que isso não está certo agora, dois em dois
no script quebrado.
E este é referente à liberdade, que não é compatível com este dispositivo no momento.
Portanto, como já foi mencionado, a Frida é absolutamente incrível e é ridículo o quanto de suporte de plataforma está
sendo fornecido para a Frida.
Mas, infelizmente, pode acontecer de estarmos usando um dispositivo com algumas bibliotecas personalizadas ou proprietárias
que não são compatíveis com a estrutura do FRIDA no momento.
Portanto, se estivermos recebendo erros como esse, se esses registros estiverem sendo impressos,
a melhor e mais fácil maneira de descobrir se é um problema relacionado ao nosso script Frida ou à compatibilidade
do Frida em relação ao nosso smartphone é experimentar esse script Frida na máquina virtual.
Se ele também falhar lá, não poderemos ter 100% de certeza se é um erro em nosso script ou se é uma incompatibilidade, geralmente
em determinada biblioteca de nosso aplicativo.
Mas se o script funcionar em nossa máquina virtual, podemos ter certeza de que não é um problema do nosso script.
Portanto, vamos experimentar isso aqui e desconectar o smartphone.
Agora, vamos iniciar a máquina virtual e estamos usando o mesmo aplicativo e o mesmo script Frida
na máquina virtual.
Tudo bem.
Está bem.
E agora vamos começar esse aplicativo mais uma vez com a Frida.
Portanto, estamos usando o Frida, o aplicativo de espaço de problemas.
Mais uma vez, aplicamos nosso script, que não terá nenhum efeito dessa aplicação.
Tudo bem.
Aumentamos um pouco o tamanho, e agora podemos retomar essa ameaça.
Podemos ver que a varredura da memória referente às instâncias de perfil foi concluída, mas nenhum dado foi
encontrado.
Vimos anteriormente que a instância do perfil já está disponível agora mesmo nessa tela de carregamento.
Portanto, podemos iniciar esse aplicativo ou experimentá-lo aqui e, por isso, entro no meu terminal
Frida aqui e uso a tecla de seta superior mais uma vez.
Agora, volto ao script e o executo mais uma vez em 3 para 1.
Vamos lá.
E aqui podemos ver que a instância do perfil foi encontrada.
Esse é o endereço da nossa instância de perfil.
No momento, a pontuação máxima é zero porque temos uma nova instalação aqui e a verificação da memória referente
a essa instância de perfil foi concluída.
Tudo bem.
Portanto, depois desse aqui, não imprimimos uma instrução de depuração adicional.
Portanto, é bem provável que agora tenhamos alterado a pontuação máxima para esse valor.
Vamos ver se clicamos em iniciar.
É isso aí.
Legal.
Portanto, a pontuação máxima foi alterada.
Tudo bem.
Portanto, agora sabemos que nosso script free to aqui funciona perfeitamente.
Portanto, não há nenhum erro.
Infelizmente, o erro que recebemos em nosso dispositivo aqui foi relacionado à interação da Frida com esse
dispositivo.
Então, talvez em relação a uma biblioteca ou outra coisa, arquitetura.
Quero dizer, esses smartphones Android têm tantos fabricantes diferentes e tantas bibliotecas proprietárias
que seria absolutamente ridículo oferecer suporte a todos eles.
Portanto, às vezes ele pode travar.
Isso é bastante lamentável.
Mas se você escrever para esse autor, eu farei isso depois.
Em seguida, ele dará uma olhada nisso e tenho certeza de que aplicará um patch para isso.
Muito bem.
Está bem.
Incrível.
Agora, vamos dar uma olhada nessa abordagem de conexão de método de classe, porque não fizemos isso há muito tempo.
Portanto, vamos fechar este aqui.
E este aqui.
E sim, vamos salvar esse aqui na primeira tentativa.
Tentativa um, vamos trabalhar nisso.
Ok, talvez possamos comentar isso aqui.
Caso contrário, é um pouco perturbador.
É isso aí.
Portanto, o que estamos fazendo agora é o seguinte.
A JVM e esta aqui estão mantendo todas essas classes e métodos.
E um deles é este, por exemplo, o método de obter pontuação alta.
E este não tem parâmetro, mas está retornando a pontuação máxima atual aqui com um número inteiro.
Esse método está sendo armazenado em cada EVM e sempre que o aplicativo acessa esse método.
Ele está usando este aqui.
Ao substituí-lo, definiremos agora uma nova implementação.
Portanto, em vez de retornar algo, podemos dizer, por exemplo, retornar 9000 e mais.
Tudo bem.
E essa é a nossa abordagem em relação à conexão de um método.
Portanto, fizemos isso no início de nossa jornada gratuita, mas não o usamos há muito tempo.
Portanto, vamos atualizar isso.
Tudo bem.
Portanto, o que precisamos fazer primeiro, mais uma vez, é dizer ao Frieda para se conectar à JVM.
Podemos fazer isso com o nosso formulário JavaScript e, em seguida, você está fornecendo uma função anônima nele.
Och, ele não tem nosso código.
E esta é a nossa tentativa de conectar a função de obter pontuação máxima.
A única desvantagem dessa abordagem é que temos de esperar até que o aplicativo acione esse método, portanto,
não podemos acioná-lo ativamente.
Quer dizer, poderíamos ter criado uma nova instância, mas já vimos que essa não
funciona em nossa memória.
Há apenas uma instância de perfil e, se estivermos criando um novo, teremos um segundo perfil com uma nova
pontuação máxima.
Mas isso não afeta em nada este aplicativo.
Portanto, em nosso jogo e neste aqui, temos apenas uma pontuação alta, uma instância de perfil.
Se criarmos um novo local, teremos uma segunda pontuação alta, mas essa não será afetada
ou vinculada a esse jogo aqui.
É inútil na memória.
Tudo bem.
Está bem.
Portanto, criar uma nova instância não faz muito sentido.
Temos que esperar até que esse método seja acionado.
E, sim, essa é a desvantagem de trabalhar ou de usar o método aqui.
Mas talvez esse método seja acionado quando mudamos o nível ou coisas do gênero, e isso seria
bom o suficiente para nós, como invasores.
Muito bem.
Então, vamos analisar o assunto.
Portanto, em nosso código, a primeira coisa que precisamos fazer é obter a referência para a classe
de perfil.
Então, aqui estamos tendo nossa referência.
Vamos colocar isso na referência de perfil correta.
E esse está dentro do pacote.
Dot e, em seguida, o nome da classe.
Tudo bem.
Agora, queremos usar essa referência de classe.
Ops.
Uma vez é suficiente, e queremos usar esse método para obter uma pontuação alta.
E agora queremos definir uma nova implementação para esse método.
Agora estamos fornecendo nossa função aqui.
Essa não é uma função que está ocorrendo aqui.
Ele está sendo usado para substituir esse método.
E aqui dentro, vejamos.
Quer dizer, a única coisa que precisamos fazer é ter zero parâmetros e obter um valor de retorno de
um número inteiro.
Portanto, a única coisa que podemos fazer aqui é retornar outro valor inteiro.
E é exatamente isso que queremos que substitua o valor de retorno.
Então, aqui estamos nós retornando.
Agora o valor, vejamos, vamos deixar isso um pouco mais claro e esse valor agora.
Então, o que eu gosto de ter aqui é algum tipo de saída de depuração que nos permita saber quando esse
método está sendo acionado e, portanto, vamos fazer isso.
Portanto, na saída de feedback, também podemos imprimir a pontuação máxima atual.
Mas acho que já fizemos tudo com esse método.
Então, vamos ver se a opção Obter pontuação máxima foi chamada com o valor de retorno.
E agora estamos chamando o método original de "get high school".
E esse é o nosso método.
Este está retornando um número inteiro e está sendo convertido diretamente em uma cadeia de caracteres.
Isso é o que é possível em JavaScript aqui.
Tudo bem.
E isso é tudo.
E vamos terminar os comentários aqui que sabemos o que está acontecendo.
Referência à classe de perfil
e, aqui, sobrescrevendo o método get high score e imprimindo a pontuação máxima atual.
E aqui estamos sobrescrevendo o valor de retorno.
Certo, agora vamos pegar esse script e iniciar nosso leitor aqui novamente.
Sim.
Com o operador com o traço F, para que o aplicativo seja iniciado.
Nós não vemos isso.
Portanto, também precisamos de nossa cópia de tela de volta.
Aqui está.
Temos a tela preta porque o aplicativo foi pausado.
Agora estamos fornecendo nosso script para esse terminal gratuito e estamos usando o currículo para prosseguir com o
aplicativo.
E isso mudará esse espaço em branco para o aplicativo.
E então, vejamos, aqui está o nosso script.
Faça isso um pouco menor.
Está bem.
Estou fazendo o currículo em três, dois, um.
Está bem.
Currículos de aplicativos.
E vamos ver.
O método não foi chamado até o momento.
Caso contrário, teríamos visto isso aqui.
Vamos clicar em iniciar.
E agora.
Que bom.
Podemos ver que esse método está sendo chamado muitas vezes.
Sim, é engraçado.
Toda vez que obtemos uma nova pontuação, estamos aumentando a pontuação máxima atual e, sim, isso é lamentável.
Podemos ver.
Estamos substituindo-o pela pontuação máxima atual.
Então, deixe-me pensar sobre o que está acontecendo aqui.
Está bem.
Portanto, tenho uma ideia do que está acontecendo, mas não tenho 100% de certeza sobre isso.
Verificaremos isso depois.
Portanto, estamos substituindo o método de obtenção de pontuação máxima.
Este aqui, no início.
Se estivermos começando o jogo, teremos um número enorme, absolutamente incrível.
Mas, depois de um certo tempo, estamos atualizando essa exibição com a pontuação máxima real e acho que essa
pontuação máxima real está sendo armazenada ou salva em qualquer lugar.
Portanto, isso pode não afetar a pontuação máxima, talvez apenas a exibição.
Está bem.
Então, como podemos corrigir isso?
Poderíamos enganchar este ou talvez este.
Esse seria um conjunto de substituição ainda melhor se a nova pontuação alta garantisse que nossa pontuação alta
fosse sempre definida no topo.
Portanto, é aqui que a pontuação máxima é atualizada.
E se você estiver conectando esse método e assumindo o controle dele, então, sim, a pontuação máxima real não poderá
mais afetar nosso jogo.
Temos controle total sobre a nova pontuação máxima ou sobre como ela está sendo definida e, portanto, essa é a melhor
abordagem para conectá-la aqui.
Acho que agora vamos resolver isso.
Portanto, essa foi uma boa tentativa, mas infelizmente não está funcionando.
Então vamos ver.
Tente três conjuntos de ganchos para obter uma nova pontuação máxima.
Speedrun.
Está bem.
Então, agora vamos ver.
Hmm.
E esse retorna um booleano e recebe esse parâmetro.
E define se esse é maior do que o anterior.
Está bem.
Portanto, o que precisamos fazer é o seguinte.
Precisamos chamar esse método mais uma vez e, então, estaremos substituindo o parâmetro.
Sim, exatamente.
Portanto.
Estamos fazendo o seguinte.
Portanto, estamos fazendo o seguinte.
Neste momento, nos conectamos a esse método e temos aqui nossa nova pontuação máxima.
Não podemos manipulá-lo agora e, portanto, temos que chamar esse método mais uma vez no método deles e, então,
poderemos assumir o controle sobre esse parâmetro.
Tudo bem.
Talvez não.
Mas deixe-me mostrar a você o que quero dizer.
E então acho que fica um pouco mais claro.
Está bem.
Portanto, precisamos chamar esse método mais uma vez.
Dito isso, se a nova escola de ensino médio OC e a TPN estiverem fornecendo nosso parâmetro, então esse
valor aqui, por exemplo, vamos alterá-lo para um número diferente.
Vamos fazer desta forma.
Assim, podemos ter certeza de que esse está sendo chamado.
Tudo bem.
Portanto, agora estamos chamando esse método mais uma vez, mas desta vez temos controle sobre
esse parâmetro que foi usado para definir uma nova pontuação, e ele está retornando em booleano.
Portanto, precisamos tomar cuidado com isso.
Vamos ver se uma nova pontuação máxima está sendo estabelecida.
Estamos retornando de verdade.
Caso contrário, falso.
Sim.
Portanto, estamos retornando.
Verdadeiro.
Não tenho certeza se isso não importa no momento, mas estamos estabelecendo um novo recorde, portanto, estamos retornando.
Verdadeiro.
Está bem.
Isso deve funcionar agora mesmo.
Eu me esqueci de uma coisa.
Queremos ver o que está acontecendo.
Portanto, vamos imprimi-lo.
Está bem.
Então está pronto.
Se a nova escola de ensino médio tiver sido chamada, você deve imprimir alguns parâmetros?
Vejamos.
Podemos imprimir o.
O parâmetro de pontuação máxima.
Está bem.
E isso é tudo.
Sim.
Vamos fazer isso.
E mais.
Sim.
Portanto, agora podemos observar isso.
Muito bem, vamos abrir livremente para inserir o script, continuando com o aplicativo.
Coloque-os em primeiro plano.
Está bem.
Portanto, acho que a cópia de tela perdeu a conexão ou algo mais.
E vamos fazer isso mais uma vez.
E aí está.
Estava em segundo plano.
Mas sim, quero dizer, a tela preta é a mesma, como conectar esse aplicativo.
Vamos fazer isso mais uma vez.
Limpo.
Então, vamos reiniciar esse aplicativo.
Agora estamos aplicando nosso script e prosseguindo com este aplicativo.
Certo, agora estamos tendo essa tela preta, mas desta vez ela se destina a assumir.
Vamos lançar nosso roteiro.
Está bem.
O conjunto da nova escola de ensino médio ainda não foi definido.
Vejamos.
Aqui está.
Tudo bem.
Podemos ver que ela foi definida aqui e que a atual escola de ensino médio foi definida como zero.
Vejamos.
Está bem.
Sim.
O aplicativo está substituindo ou tentando substituir a pontuação máxima atual.
Este aqui.
Mas, depois disso, continuamos a substituí-lo novamente por esse valor.
Portanto, o aplicativo não tem mais chance de influenciar essa pontuação alta.
Isso significa que se fecharmos esse aplicativo.
O roteiro de Frida é desconectado, portanto não estamos mais ligados a ele.
Vamos abrir esse aplicativo e ver se a escola de ensino médio será salva.
Nível quatro.
É isso aí.
Mas não temos certeza no momento.
Ok, agora podemos ter certeza.
Sim.
Portanto, também não teremos mais um roteiro de Frida anexado.
Tudo bem.
Para ser sincero, não esperava tanto esforço para simplesmente substituir isso por um monte
de métodos diferentes.
Mas, quero dizer, é bom que tenhamos visto isso aqui.
Portanto, agora conhecemos pelo menos duas abordagens para influenciar esse método.
Acho que a abordagem referente ao campo de instância também deve funcionar.
Você pode tentar essa opção, mas tenho certeza de que essa é a mais fácil e a mais confiável.
No entanto, agora você tem três possibilidades.
Está bem.
Tudo bem.
Acho que este vídeo já está um pouco longo, por isso estou fazendo uma espécie de speedrun em relação a todas
as outras funcionalidades.
Vamos dar uma olhada nos slides.
O que está sobrando aqui?
Sim.
Então, agora.
Uau, muito bem.
Temos a vida e o ensino médio.
Há apenas fogo rápido, chuva invisível, invencível e novo jogador.
O novo jogador não é algo que não podemos fazer no momento, mas o restante.
Portanto, temos quatro métodos restantes.
No entanto, vamos fazer isso aqui.
Portanto, se isso não for entediante para você, não há problema algum.
Sinta-se à vontade para pausar ou encerrar este vídeo agora mesmo e seguir para o próximo.
Caso queira ver alguma prática relacionada a esse jogo, então, sim, você é bem-vindo para ficar e depois
faremos uma corrida rápida.
Portanto, tento fazer isso em menos de 20 ou 30 minutos em relação a todas as outras coisas aqui.
Muito bem, vamos tentar isso.
Está bem.
Portanto, volte para a vm do Ubuntu.
Eu diria que a modificação da pontuação máxima aumentou muito rapidamente.
Quero dizer, há abordagens fáceis, por exemplo, modificar o campo de instância e este aqui
ou simplesmente chamar um método de instância assim ou assim.
No entanto, para mim, neste momento, era importante também atualizar nosso conhecimento antigo.
Por exemplo, conectar um método como fizemos aqui.
Tudo bem.
Está bem.
Para o restante, faremos uma espécie de speedrun e, portanto, começaremos diretamente aqui.
Então vamos ver.
Está bem.
Portanto, a próxima é sobre nosso modo de disparo rápido e já vimos isso em nossa abordagem de sorriso.
Portanto, não havia tempo suficiente para filmar.
E se esse valor estiver sendo definido como baixo, por exemplo, zero, então teremos a capacidade de atirar sempre.
Vamos encontrar isso mais uma vez.
Portanto, estamos usando a função de pesquisa neste caso e depois vamos ver na hora de fotografar.
Acho que foi assim.
Sim.
Sistema de entrada do jogador.
Aqui está.
Agora estamos no sistema de entrada do jogador de classe e aqui temos essa instância de tempo de campo para atirar.
Vamos ver se ele está sendo usado.
Portanto, estou apertando o controle f e depois é hora de atirar.
Vejamos.
Encontre.
E aqui está.
E esse é o nosso estado de incêndio.
Sim.
Assim, entramos no estado permitido se este disparo e este tempo de disparo, este aqui, for menor que zero.
Está bem.
E essa rota precisa ser definida como um valor booleano.
Verdadeiro.
Está bem.
Portanto, para mim, no momento, parece que se mantivermos esse valor definido como zero, não seremos bloqueados.
Quero dizer, aqui está sendo aumentado.
Isso deve garantir que ele esteja sendo bloqueado depois de ter sido executado e disparado.
Portanto, sim, isso deve funcionar no momento.
O que estamos fazendo é o seguinte.
Substituiremos esse valor o tempo todo para que seja zero.
Portanto, estamos mantendo esse valor em zero.
Portanto, estamos examinando a memória desse aplicativo, encontrando essa instância de entrada do jogador, encontrando
esse campo aqui.
E então escrevemos em um loop que está sendo definido como zero.
Tudo bem.
Está bem.
Portanto, vamos dar uma olhada.
Portanto, estamos abrindo um novo arquivo.
E este, vamos salvá-lo.
E agora é o Rapid Fire Chase.
Vamos fazer isso mais uma vez.
Código Java, Java Dot, executar mais instância, e agora vamos simplesmente acessar esse campo.
Onde temos isso aqui?
Esse é um campo flutuante.
Portanto, agora acessando o campo de instância.
Hora de atirar.
Portanto, o tempo do ponto de exemplo para disparar o valor do ponto é igual a zero.
Agora precisamos ter certeza de que esse valor está sendo definido como zero o tempo todo.
Portanto, estamos colocando isso agora em um loop y e depois em um loop y true.
Portanto, isso manterá permanentemente esse valor em zero.
E essa pode não ser a abordagem mais limpa.
Mas, se funcionar e se você não tiver grandes desvantagens em relação a atrasos ou coisas do gênero,
será bom para mim e para você também.
Ok, então podemos fazer isso.
Está bem.
Então, o que temos que fazer é simplesmente colocar nosso tempo, acho que é espero que esteja
no JavaScript dessa forma, frutas silvestres e então estamos colocando isso.
Vamos ver se isso funciona.
Portanto, precisamos fazer nossa conexão com nossa VM.
Sim.
Este não está mais disponível.
Preciso reiniciá-lo.
Está bem.
Acho que já está disponível.
Vejamos.
Sim.
Agora também precisamos reiniciar nosso servidor gratuito.
Portanto, dentro do registrador de dados dez.
Vamos reiniciar isso rapidamente.
Aqui está.
E agora vamos começar a rodar livremente.
Portanto, você pode se divertir com isso.
Sim.
Está bem.
Quero dizer, nesse caso, podemos continuar com esse aplicativo porque essa instância não estará disponível
no momento.
Está bem.
Portanto, aqui temos nosso aplicativo espacial que está preparado.
É muito rápido porque, se eu for muito ruim, posso morrer muito rápido.
Portanto, nível quatro.
Vejamos.
Sim.
Portanto, talvez não consigamos mais obter uma saída porque estamos no loop Y.
Está bem.
Infelizmente, isso é verdade.
Mas vamos ver se nosso patch foi aplicado.
Eu não tinha tempo para fotografar agora.
Então vamos ver.
Aqui está.
Tudo bem.
Isso está funcionando.
Incrível.
Quero dizer, estamos bloqueando grandes coisas nesse aplicativo no momento.
Definitivamente, não é a melhor abordagem, mas está funcionando.
Portanto, para mim, não há problema algum.
Então, se nós.
Vamos fechar esse aqui.
Vejamos.
Está bem.
Agora, temos nosso resultado e podemos ver a qualidade.
Esse valor parece ainda estar sendo corrigido.
É incrível porque desconectamos nossa liberdade.
Então, melhor ainda.
Está bem.
Portanto, o modo de disparo rápido também foi alcançado.
Vamos comentar isso aqui rapidamente.
Está bem.
Seguro.
Feito.
O próximo.
Está bem.
Portanto, o próximo é invisível.
Parece absolutamente incrível.
Como podemos conseguir isso?
Bem, se você der uma olhada mais de perto no aplicativo novamente.
Então, aqui está.
Agora, se você estiver sendo atingido, há cerca de 13 eventos que são cursos.
Vejamos.
Podemos ver que agora não temos mais nenhum jogador e agora ele está sendo respondido.
Portanto, isso é exatamente o que precisamos ter para tornar nosso jogador invisível.
Vamos encontrar esse evento e, portanto, vamos fechar esse aplicativo primeiro, porque meu ventilador está girando
um pouco loucamente agora.
Agora, vamos localizar esse evento e colocá-lo em primeiro plano.
E o que temos de procurar é se o objeto do jogador foi atingido, talvez por colisão, se você está perdendo
uma vida ou se o objeto do jogador morre.
Portanto, esses são os termos que estamos procurando.
Acho que a melhor opção é identificar quando o jogador está perdendo uma vida, porque antes ou depois esse
evento será acionado.
Portanto, vamos dar uma olhada.
Portanto.
Não.
Não queremos salvar este ou dois, não este.
Portanto, estamos buscando vidas.
Menos.
Vamos fazer desta forma.
E temos um no sistema do diretor.
Vamos ver se este está correto e se o jogador foi liberado.
Legal.
Este é exatamente o que queremos ter.
Quero dizer, não no jogo, mas aqui.
Esse foi realmente um golpe de sorte, ou seja, o compilador, na maior parte do tempo, está reduzindo e a vida é igual
à vida menos um para este.
Portanto, esse é realmente um bom termo para pesquisar.
Ok, incrível.
Então, vejamos que aqui temos vários estados de jogadores.
Este aqui é isso.
Está bem.
Incrível.
Encontrei esse método aqui.
Ele também é chamado de Z Player.
Invisível.
Ok, este é um método de instância.
Portanto, basta obter a instância em nossa memória e, em seguida, chamar esse método.
Isso deve tornar o jogador invisível.
Sim.
Está bem.
Isto é.
Isso é incrível.
Pensei que teríamos que passar para outra função, mas dessa forma.
Absolutamente incrível.
Então, vamos fazer isso.
Nós o encontraremos.
Encontre s seguros e, em seguida, has escuros invisíveis.
Vamos colocar isso à direita.
E vamos manter o controle do player definido nesse player definido invisível.
Vamos fazer uma anotação aqui.
Portanto, este é o nome do pacote.
Está bem.
Então, mais uma vez, Chava pensou em agir.
O que também é bom é dar uma olhada nessas classes.
Quero dizer, preparei agora alguns métodos que achei bastante interessantes, mas isso não significa que
sejam os únicos.
Portanto, talvez existam outros itens adicionais.
E se você brincar com isso e escrever alguns scripts gratuitos incríveis, eu adoraria ter algumas
capturas de tela do aplicativo que você modificou ou talvez alguns vídeos curtos, digamos, de 10 segundos
ou coisas assim.
Portanto, se quiser me enviar, ficarei muito feliz com este, com o progresso que estamos fazendo
juntos.
Muito bem.
Está bem.
Portanto, voltemos a essa referência de classe.
Está bem.
Liberte esse traço que você f.
Sim.
Estamos trabalhando novamente com uma instância.
Portanto, vamos aplicar isso.
Isso não funcionará.
Mas, mesmo assim, vamos fazer isso.
Está bem.
Sim.
Não há nada aqui.
E também, se estivermos retomando, podemos ver que nenhuma instância de jogador foi encontrada.
Agora já estamos no nível oito.
Incrível.
Então vamos ver.
Está bem.
Tenho que limpar isso à esquerda bem rápido, pois, caso contrário, posso estar morto até que possamos testar
isso.
Então, agora vamos ver.
Estou copiando e colando mais uma vez.
E agora com o limite de estatísticas de 3 para 1 ativado.
Aqui está.
Ok, legal.
Vamos ver se ainda podemos atirar.
Sim.
Incrível.
Portanto, agora somos invisíveis.
Vamos ver se você também é invisível.
Não.
Estamos perdendo uma vida e podemos ver essa explosão de jogadores e esse estado de prontidão.
Sim, não somos invencíveis, mas invisíveis também não são tão ruins.
Muito bem, vamos comentar isso rapidamente.
Vou avançar rapidamente e depois daremos uma olhada na próxima.
Está bem.
Então, aqui está.
Agora vamos dar uma olhada.
Seja invencível.
E eu vi algo aqui.
Reprodutor de fita cassete Collider.
Isso fará com que nosso jogador seja o Collider.
Portanto, vamos ver se temos alguma contrapartida com relação a isso.
Tudo bem.
É exatamente isso que queremos ter.
Portanto, se um jogador for atingido, temos alguma imunidade por um curto período de tempo.
Isso acontece em muitos jogos.
Portanto, isso é bom e queremos nos conectar a ele.
E sim, talvez possamos manter o estado ativo se pudermos mantê-lo ativo, e então o jogador será
invencível.
Muito bem, vamos fazer isso.
Então, vamos voltar a esse caso.
Podemos salvar essa.
Agora, vamos fechá-los.
Guardamos este, este e este.
E agora estamos criando um novo script.
Vamos renomear esse arquivo para salvar, pois agora ele é invencível.
Em resumo, execute uma função anônima.
Então vamos ver.
O que temos aqui?
Neste caso.
Mais uma vez, isso está dentro da classe do sistema diretor.
Sim.
E aqui podemos ver que este é o layout de configuração após a configuração dos loops, após a peça ter sido
configurada aqui por um curto período de tempo e colidido.
Projeto de lei.
Então, vamos voltar.
Sim.
Mais uma vez, precisamos buscar essa instância do sistema diretor.
Precisamos obter essa instância e, em seguida, aplicar o estado permanentemente.
Está bem.
Portanto, este é o nosso plano no momento.
Vejamos.
Este aqui é um método, um método de instância.
Portanto, mais uma vez precisamos encontrar esse sistema de diretório.
Por exemplo, há apenas um disponível.
Já vimos isso na última abordagem e, em seguida, simplesmente chamamos esse método em nossa instância.
Não tenho certeza se esse será capturado, portanto, talvez tenhamos que mantê-lo pressionado, como em relação
ao tempo para disparar o campo de instância em um loop amplo, ou simplesmente temos que chamá-lo uma vez, pois o estado original
pode não ser restaurado.
Temos que descobrir isso.
Está bem.
Portanto, vamos ver.
Sim.
Valor de retorno.
Branco E aqui também não estamos fornecendo nenhum parâmetro.
Está bem.
Tudo isso é bom.
Está bem.
Vamos ver se isso funciona.
Mais uma vez, estamos começando com a Frida.
Mais uma vez, estamos iniciando a cópia da tela.
Och Frida foi aprovado na aplicação.
Então, clicamos em retomar.
Aqui temos este aplicativo.
Não, vamos entrar no nível oito.
E estou aplicando esse em dois um.
Vamos contar a partir de três.
Não tenho certeza do que.
Qual era o motivo agora?
Três, dois, um.
Vamos lá.
Tudo bem.
Nós vimos ou encontramos.
Portanto, aqui podemos ver que encontramos uma instância do sistema do diretor e, ainda assim, terminamos de examinar essa memória e podemos
ver que não conseguimos ser atingidos.
Sim.
Por isso, diz-se que o jogador não pode ser cobrado.
Acho que esse é o estado.
Incrível.
Também podemos buscar moedas?
Não.
Ok, agora podemos.
Oh, podemos colidir com alienígenas.
Mas nós não morremos.
Não, não podemos cobrar.
Desculpe, mas isso não foi do meu agrado.
Tudo bem, agora não podemos colidir com nada.
Isso significa que não podemos coletar itens.
Mas também não podemos morrer.
Acho que é isso.
Isso é injusto.
Comércio justo.
Em relação a um jogo como esse.
Sim.
E também podemos ver que precisamos acioná-lo apenas uma vez.
Portanto, não precisamos mantê-lo em um loop amplo porque o estado do jogador foi definido fora daqui, digamos,
fora do alcance.
Portanto, com relação aos estados individuais, eles se sobreporão uns aos outros posteriormente.
Mas agora estamos fora dessa cadeia, e esse estado de jogador aqui não pode ser substituído novamente.
Isso é absolutamente incrível e nos poupa muitos recursos em nosso script gratuito.
Tudo bem.
Esse também foi feito.
Vamos comentar isso aqui em um speedrun e depois vamos ver o que resta.
Está bem.
Portanto, aqui temos nosso script.
E agora vamos ver o que vem a seguir.
Está bem.
Por último, mas não menos importante, eu pulei isso de repente.
Mas, mesmo assim, estamos fazendo isso agora.
Essa é a nossa linha de moedas.
Portanto, em nosso aplicativo, em relação a uma determinada quantidade de vezes, haverá a geração de algumas moedas
e o escudo de tiro duplo e o aumento de nível.
Agora vamos encontrar isso no código do aplicativo e ver como podemos acioná-lo por nós mesmos.
Portanto, aqui temos esse código de aplicativo.
Estamos procurando agora, vamos chamar de moeda.
Ele terá uma aula sobre moedas.
Quero dizer, isso parece absolutamente promissor.
Sim.
Então, aqui temos esse copo.
Mas não consigo ver um método que esteja criando uma nova moeda.
Portanto, poderíamos conectar a construção deste e chamar este.
Mas isso parece um pouco complicado no momento.
E vamos dar uma olhada nos outros óculos aqui.
Neste caso.
Isso também não é interessante.
Essa janela não foi aberta.
Isso abrirá isso mais uma vez.
E eu arrasto e solto isso agora na parte inferior.
E então estávamos nesta aqui.
Em seguida, temos uma tela, uma tela de crédito.
Aqui.
Podemos dar alguns créditos aos autores graças a esse aplicativo incrível aqui na tela do jogo,
onde temos duas partidas.
Mas esse sistema correspondente parece promissor.
Então, vamos clicar duas vezes nesse aqui.
Ah, não está funcionando dessa forma no Eclipse.
Portanto, vamos pesquisar esse também.
Está bem.
E depois temos este.
Aqui temos o sistema de localização de moedas do site de desova de moedas, a classe Java.
Está bem.
E vamos ver se podemos usar algo aqui.
Aqui está.
Aqui estamos nós, com um método para distribuir moedas aleatórias.
Portanto, este está usando os utilitários matemáticos.
Random, e ele está criando um novo número aleatório aqui.
E, com base nisso, se for menor que 0. 1 e flutuante, estamos recebendo esse escudo de vida extra e o tiro
duplo.
Portanto, agora pode ser interessante saber se o gerador de números ou o caso aqui está preferindo uma determinada
moeda ou se ela é realmente igual, porque aqui temos esse intervalo e esse intervalo com igual e assim
por diante.
Está bem.
Portanto, pode ser que a moeda aqui esteja sendo preferida, que ela ocorra com mais frequência
do que outras.
No entanto, não nos importamos com isso.
Agora podemos ver que ela pode ser usada para criar uma nova moeda.
Portanto, aqui temos essa fábrica de entidades criando moedas.
Estamos tendo dois parâmetros neste mundo, que acho que é a palavra do aplicativo, e depois temos
o tipo de moeda, o escudo de vida extra e o tiro duplo.
Sim.
E esse não pode ser influenciado por nós no momento.
Quero dizer, poderia ser, mas não dentro desse método.
Aqui, não temos parâmetros nem valor de retorno.
Portanto, se você quiser influenciar este, temos que pegar ou enganchar este aqui.
Vejamos.
Criar moeda.
Talvez seja isso.
Esse parece ser um método estético, mas é necessário.
Está bem.
Não sabemos isso no momento.
Aqui estamos nos referindo a determinados objetos.
Estamos tendo um objeto mundial e uma vida extra.
Isso é algo que aprenderemos na próxima seção.
Então, aqui podemos ver o que estamos aprendendo na próxima seção, fornecendo instâncias existentes à nossa
chamada, para que possamos aprender como fornecer instâncias existentes ao nosso método.
Olhando para cá, por exemplo.
Ok, esse parece ser muito bom, mas infelizmente temos que nos concentrar neste primeiro.
Quero dizer, não podemos definir o tipo de moeda, mas podemos fazer chover.
Isso é suficiente para nós no momento.
Ok, vamos fazer isso.
Portanto, salvamos este aqui e, em seguida, criamos um novo.
E isso agora é moeda por moeda.
Certo.
Duquesa e Chava Dot se apresentam então?
Sim.
Portanto, mais uma vez, precisamos buscar a instância.
O uso desse método não nos dá nenhuma vantagem.
E, em primeiro lugar, não podemos chamá-lo ativamente, o que é absolutamente necessário neste momento, e não
temos um parâmetro ou valor de retorno.
Portanto, conectar esse método não faz sentido.
Temos que fazer o trabalho para escolher a abordagem.
Tudo bem.
Está bem.
Portanto, mais uma vez, estamos fornecendo nossa função anônima.
Esse não tem o tipo de retorno ou o tipo de retorno é nulo.
Desculpe, mas este não tem o valor de retorno e não tem parâmetro.
Portanto, é assim que podemos chamar esse método.
Um novo terminal ou liberdade.
Chris, você.
Bit Nível oito.
Primeiro, vamos criar algum espaço.
Que não temos pressa em acionar esse método.
Está bem.
Então, vejamos, eu o colo agora mesmo e pressiono enter em três e dois.
Um, e aí está.
Pode ser sorte.
Vamos fazer isso mais uma vez.
Sim.
Portanto, aqui podemos ver que está funcionando.
Legal.
Isso parece absolutamente incrível.
E eles funcionam.
Sim.
Está bem.
Portanto, isso está funcionando no momento.
Fantástico.
Mas é um pouco.
Sim, não é muito conveniente fazer isso dessa forma.
Portanto, vamos envolver isso em uma função e gerar uma moeda.
Está bem.
Portanto, se estivermos aplicando este, este não é o nosso código no momento.
Portanto, estamos apenas fazendo com que você envolva isso em uma função e, agora, se estiver chamando essa função
pelo nome da função, vamos ver a moeda de desova.
Então, podemos ver que sim, isso está funcionando e agora também podemos fazer isso com um pouco mais de frequência.
Por exemplo, aqui podemos dizer que quatro barras são iguais ou barra I é igual a zero.
I é menor que 100 I mais mais.
Portanto, agora estamos criando 100 moedas.
Sim, isso deve funcionar.
Mais uma vez, aplique isso à interface da linha de comando aqui.
Isso não acionará ativamente esse método porque o envolvemos em uma função.
Agora, se chamarmos esse método mais uma vez e gerarmos um chamador, espero que esse B não trave.
Vejamos.
Está bem.
Parece funcionar.
Até onde podemos ir?
Tudo bem.
Portanto, essa é definitivamente uma chuva de ponto final.
E podemos ver que todas essas vidas estão subindo, mas nós também estamos presos na abertura.
Isso é algo que corrigiremos em algumas seções mais adiante.
Ok, legal.
Então, aqui podemos ver.
Podemos fazer chover moedas.
Incrível.
Muito bem.
Portanto, isso é tudo para este vídeo no momento.
Foi bem longo.
Desculpe-me por esta, mas não quero me apressar.
Portanto, gostaria de apresentar algumas abordagens sobre como identificar determinados eventos e coisas do gênero.
Está bem.
Portanto, aqui nos renovamos e aprendemos muitas coisas.
Além disso, aprendi muito neste vídeo com relação à nossa primeira tentativa de atingir a pontuação
máxima e, no próximo, aprenderemos mais sobre objetos como parâmetro.
Portanto, se você ainda estiver assistindo a este vídeo, muito obrigado.
É realmente incrível que você tenha feito isso comigo agora mesmo e, ainda assim, sinta-se à vontade
para brincar com este aqui.
Quero dizer, pode haver também algumas funções adicionais interessantes, que talvez eu não tenha descoberto
até o momento.
Portanto, brinque com esse vídeo e, caso contrário, espero vê-lo no próximo vídeo.