Jogo de dinossauro Google Chrome Python bot.

Taras Rumezhak Segue 18 de jul · 4 min ler

Olá pessoal, hoje vamos construir um bot python muito simples. Nós não vamos usar o aprendizado profundo. É um bot muito simples que usa apenas processamento de tela.

Considero este tutorial um ótimo começo para iniciantes, porque é muito fácil, mas muito empolgante.

Existem cerca de cinquenta linhas de código, apenas uma classe de bots e nada mais. Então vamos começar.

Como sempre, precisamos de algumas bibliotecas para serem importadas.

Trending AI Articles:

1. Notas do Livro de Aprendizagem Profunda, Capítulo 1

2. Notas do Livro de Aprendizagem Profunda, Capítulo 2

3. Máquinas Demonstram Autoconsciência

4. Workshop de Música Visual e Aprendizagem de Máquina para Crianças

Aqui estão eles:

 da importação PIL ImageGrab, ImageOps 
importação pyautogui
tempo de importação
import numpy como np

Precisamos da biblioteca PIL para pegar nossa área de jogo e processá-la. A segunda biblioteca é pyautogui, é uma ótima ferramenta para controlar o mouse e o teclado pelo seu código. A biblioteca de tempo é necessária para que façamos alguns atrasos entre a execução dos blocos de código. E numpy converterá nossa imagem em array para facilitar o processamento. E vamos para a nossa aula:

 bot de classe: 
"" "Bot para jogar o Chrome dino run game" ""
def __init __ (self):
self.restart_coords = (480, 503)
self.dino_coords = (207, 534)
self.area = (self.dino_coords [0] + 90, self.dino_coords [1],
self.dino_coords [0] + 150, self.dino_coords [1] + 5)

Ao inicializar o objeto de classe, precisamos especificar alguns parâmetros importantes: as coordenadas do botão de reinicialização, as coordenadas do dinossauro e as coordenadas da área do retângulo onde os obstáculos serão detectados. Falando francamente, não precisamos usar o mouse para clicar no botão de reinicialização, porque podemos fazer isso pressionando o espaço. Mas será bom que você saiba como controlar o mouse para seus próprios bots em outros projetos.

NOTA: no código acima, há coordenadas para o meu monitor. Para o seu bot eles podem ser diferentes. Você pode usar o Screen Loupe ( http://www.gregorybraun.com/Loupe.html ) para descobrir as coordenadas de um determinado pixel ou usar um redator de imagens para fazê-lo.

 def set_dino_coords (self, x, y): 
"" "
Alterar as coordenadas padrão do dino
: param x: superior direito x coordenada (int)
: param y: superior direito y coordenado (int)
: retorno : Nenhum
"" "
self.dino_coords = (x, y)

def set_restart_coords (self, x, y):
"" "
Alterar coordenadas do botão de reinicialização padrão
: param x: centro x coordenada (int)
: param y: centro y coordenada (int)
: retorno : Nenhum
"" "
self.restart_coords = (x, y)

def restart (self):
"" "
Reinicie o jogo e defina a execução de rastreamento padrão
: retorno : Nenhum
"" "
pyautogui.click (self.restart_coords)
pyautogui.keyDown ('down')

Eu especifiquei métodos adicionais para permitir que você definisse suas próprias coordenadas. Você pode brincar um pouco e explorar quais são os melhores. Leia a documentação do método! E reinicie o método apenas faz o mouse clicar em coordenadas específicas e fazer o nosso dinossauro rastejar.

 salto do def (auto): 
"" "
Salte sobre o obstáculo
: retorno : Nenhum
"" "
pyautogui.keyUp ('down')
pyautogui.keyDown ('space')
time.sleep (0,095)
pyautogui.keyUp ('espaço')
pyautogui.keyDown ('down')

def detection_area (self):
"" "
Verifica a área para ter obstáculos
: retorno : flutuar
"" "
image = ImageGrab.grab (self.area)
gray_img = ImageOps.grayscale (imagem)
arr = np.array (gray_img.getcolors ())
# print (arr.mean ())
return arr.mean ()

O método Jump clica no botão de espaço e faz o nosso dino saltar. Então há um pequeno atraso (você pode mudá-lo) e depois disso, o dino começa a engatinhar novamente. O próximo método captura a área da tela que foi definida por nós na inicialização, processa-a, converte-a em uma matriz e retorna a média dessa matriz.

 def main (self): 
"" "
Loop principal do jogo
: retorno : Nenhum
"" "
self.restart ()
enquanto verdadeiro:
if self.detection_area () <273:
self.jump ()

O principal método controla todo o processo. Ele reinicia o jogo e se alguns obstáculos forem detectados, faz um salto sobre eles.

 bot = bot () 
bot.main ()

Depois de criar a classe, precisamos apenas criar a instância da classe Bot e chamar o método main.

É isso, acabamos de criar um bot incrível. Para testá-lo, use este link: http://www.trex-game.skipser.com/ porque não há alterações dia / noite.

Eu testei em meia tela, então as coordenadas serão diferentes para o jogo em tela cheia. Descubra e altere-os em atributos.

Eu vou melhorar o jogo adicionando detecção de mudanças dia e noite e aumentando sua pontuação. O problema é que a velocidade está aumentando e devemos pular mais rápido. Isso pode ser feito movendo-se a área de detecção para o lado esquerdo toda vez para um número de pixels. Infelizmente, ainda não calculei isso, mas farei isso mais tarde.

Muito obrigado pela leitura! Por favor, deixe a resposta, é muito importante para mim.

Não se esqueça de nos dar o seu ?!