3 IAs no Dino do Google

Três formas diferentes de aprender

As três IAs recebem o mesmo jogo, os mesmos sensores e as mesmas três ações (correr, pular ou abaixar). O que muda é como cada uma descobre o que fazer. Uma evolui como uma espécie; as outras duas ajustam pesos por gradiente, recompensa a recompensa.

O que as IAs enxergam?

Nenhuma delas vê pixels. A engine do jogo (Jogo/dino_env.py) entrega um vetor de 10 números normalizados, no estilo do OpenAI Gym, e espera de volta uma ação discreta: 0 correr, 1 pular, 2 abaixar.

O Terminal: a Ponte Neural

Vencer no simulador é uma coisa. A pergunta do vídeo era outra: a campeã consegue jogar o Dino de verdade, o do Chrome? Para responder sem trapaça, construímos um terminal que não recria o jogo e não simula física paralela. Ele lê o estado real do chrome://dino, converte para o vetor que a rede aprendeu, roda a inferência e envia teclas reais de volta para o Chrome.

Os comandos no console do Chrome

Antes de escrever a ponte, precisávamos de uma resposta simples: dá para ler o jogo por dentro? O Dino do Chrome é o projeto open-source t-rex-runner, e a instância do jogo costumava ficar em window.Runner.instance_. Costumava. Estes são os comandos, na ordem em que foram descobertos.

1. Abrir um Chrome com depuração remota

Um perfil isolado, em uma porta local. Nada do seu Chrome pessoal é tocado.

chrome.exe ^
  --remote-debugging-port=9222 ^
  --remote-debugging-address=127.0.0.1 ^
  --remote-allow-origins=http://127.0.0.1:9222 ^
  --user-data-dir="chrome_debug_profile" ^
  --no-first-run --no-default-browser-check

2. Ver as abas abertas pelo protocolo

Se isso responder um JSON, o Chrome está ouvindo. Cada aba traz o seu webSocketDebuggerUrl.

http://127.0.0.1:9222/json/list

3. O caminho "clássico" — que não funciona mais

Na aba chrome://dino, abra o DevTools (F12 → Console). Nas versões atuais do Chrome (testado na 153), a classe do jogo não é mais exposta globalmente: só sobram enums como RunnerClasses.

window.Runner && (window.Runner.instance_ || window.Runner.getInstance?.())

4. O truque que achou o jogo

O jogo escuta keydown no document, e o listener registrado é a própria instância do Runner (ela implementa handleEvent). getEventListeners() é uma função exclusiva do Console — basta procurar o listener que tenha tRex e horizon.

globalThis.jogoDino = getEventListeners(document).keydown
  .map(i => i.listener)
  .find(l => l && l.horizon && l.tRex)

5. Ler o estado do jogo ao vivo

Com jogoDino na mão, tudo que a IA precisa está a um comando de distância — o dino, a velocidade, a distância e a lista de obstáculos.

// o dinossauro
({ xPos: jogoDino.tRex.xPos, yPos: jogoDino.tRex.yPos, jumping: jogoDino.tRex.jumping, ducking: jogoDino.tRex.ducking, groundYPos: jogoDino.tRex.groundYPos })
// ← {xPos: 24, yPos: 93, jumping: false, ducking: false, groundYPos: 93}

// a partida
({ velocidade: jogoDino.currentSpeed, distancia: Math.round(jogoDino.distanceRan), playing: jogoDino.playing, crashed: jogoDino.crashed })
// ← {velocidade: 6.559, distancia: 1736, playing: false, crashed: true}

// os obstáculos à frente
console.table(jogoDino.horizon.obstacles.map(o => ({ tipo: o.typeConfig.type, x: o.xPos, largura: o.width })))
// ← 'cactusSmall' x=58 largura=17 · 'cactusSmall' x=324 largura=34

// reiniciar depois do game over
jogoDino.restart()

6. A mesma coisa, mas em Python (sem colar nada)

O terminal não pede para você abrir o Console. Runtime.evaluate aceita includeCommandLineAPI: true, que libera getEventListeners fora do DevTools. As teclas vão por Input.dispatchKeyEvent, e a navegação por Page.navigate (o Chrome moderno ignora chrome://dino passado por linha de comando).

# ler o estado (a expressão JS é a mesma do console, embrulhada em JSON.stringify)
ws.send(json.dumps({"id": 1, "method": "Runtime.evaluate", "params": {
    "expression": JS_READ_STATE,
    "returnByValue": True,
    "includeCommandLineAPI": True,   # libera getEventListeners fora do Console
}}))

# pular: uma tecla real, não um evento sintético na página
ws.send(json.dumps({"id": 2, "method": "Input.dispatchKeyEvent", "params": {
    "type": "keyDown", "key": " ", "code": "Space", "windowsVirtualKeyCode": 32, "text": " "
}}))
# ... e "keyUp" só quando tRex.jumping voltar a False (teto de segurança: 0,7 s)

# abrir o jogo numa aba em branco
ws.send(json.dumps({"id": 3, "method": "Page.navigate", "params": {"url": "chrome://dino"}}))

7. Do Chrome para a rede: a tabela de conversão

O treino usa uma tela fixa de 1400×700; o canvas do Chrome tem tamanho variável. As distâncias e larguras são reescaladas pela proporção do canvas antes da fórmula original — a hipótese é que "fração da tela" é o que a rede realmente aprendeu.

Obstáculos já ultrapassados são ignorados nos dois lados (x + largura < tRex.xPos). Tudo é lido de forma defensiva: se um campo não existir nesta versão do Chrome — como tRex.config, que veio {}, ou height, que veio undefined — ele volta null e é reportado, nunca inventado.

Como saber se funcionava?

Ler código não prova nada contra um Chrome de verdade. Por isso a ponte tem uma bateria de 12 testes de ponta a ponta que precisam do Chrome aberto em chrome://dino. Cada um valida um elo da corrente: conexão, descoberta do jogo, leitura, envio de tecla, confirmação, carga da campeã, liberação das teclas e log.

pip install -r chrome_bridge/requirements_bridge.txt   # pygame-ce, neat-python, websocket-client
chrome_bridge\launch_chrome_debug.bat                  # abre o Chrome isolado na porta 9222
python chrome_bridge\smoke_test_bridge.py              # os 12 testes
python chrome_bridge\main.py                           # o terminal (1 espelho · 2 manual · 3 campeão)

[PASS] 1_conexao_porta_cdp        — 4 alvo(s) encontrados em 127.0.0.1:9222
[PASS] 2_localizar_alvo_dino      — chrome://dino já estava aberto (chrome://dino/)
[PASS] 3_descoberta_runner
[PASS] 4_leitura_estado           — speed=6.035 tRex={'xPos': 24, 'yPos': 93, 'jumping': False, 'ducking': False, 'groundYPos': 93, 'config': {}} obstaculos=0
[PASS] 5_modo_espelho_sem_teclas  — nenhuma tecla foi retida durante leituras somente-leitura
[PASS] 6_envio_manual_salto       — Input.dispatchKeyEvent(Space) enviado sem exceção
[PASS] 7_pulo_so_apos_confirmacao_chrome — tRex.jumping ficou True após o comando
[PASS] 8_carregamento_campeao_io  — NEAT (8 entradas) -> 2, PPO (10 entradas) -> 0, DQN (10 entradas) -> 2
[PASS] 9_inferencia_sem_alterar_checkpoint — nenhum checkpoint teve o mtime alterado
[PASS] 10_liberacao_teclas
[PASS] 11_persistencia_cor
[PASS] 12_criacao_log             — chrome_bridge\logs\session_20260921_224723.csv

PASS=12  FAIL=0  SKIP=0

Detalhe honesto: se o Chrome estiver em game over quando a bateria rodar, o teste 6 é pulado e o 7 falha (não existe pulo para confirmar). Na primeira rodada de hoje foi exatamente isso — 10 PASS, 1 FAIL, 1 SKIP. Reiniciar a partida e rodar de novo dá os 12.

O diagnóstico do pulo

Uma dúvida clássica: segurar a tecla mais tempo pula mais alto? smoke_test_bridge.py --jump-diagnostic segura Espaço por 60, 150 e 300 ms e mede altura e tempo de voo pelo tRex.yPos:

Conclusão medida, não achismo: o pulo do Chrome tem altura e duração praticamente fixas (~72 px, ~160 ms). O número teórico da simulação (~83 px) foi substituído pelo medido no adaptador de observação.

Resultados e Aprendizados

• Busca populacional venceu a exploração aleatória. O ponto ótimo do pulo é uma agulha estreita; o NEAT a encontra selecionando pelo episódio inteiro, enquanto DQN e PPO só destravaram com demonstrações, reescala das entradas e avaliação gulosa antes de salvar.
• A rede campeã é mínima. 8 sensores disponíveis, 2 usados, 5 conexões. Evolução não adiciona o que não precisa.
• Ler o jogo real é possível, mas o Chrome mudou. window.Runner não existe mais; o listener de keydown é a porta de entrada, e includeCommandLineAPI permite usar o truque pelo protocolo, sem colar nada no Console.
• A conversão de escala é uma hipótese, não um fato do código. O treino usa 1400×700 fixos; o canvas do Chrome varia. É a razão mais provável de a campeã morrer antes no Chrome do que no simulador — e um bom próximo experimento: treinar direto no jogo real, pela ponte.
• Teste contra o sistema real. Cadência de decisão, sleep bloqueante, aba oculta, parênteses no .bat: nenhum apareceu na leitura estática. Todos apareceram no smoke test.