Ensinei uma IA a pilotar no Circuito 1: de 43s para 24,767s só com as setas do teclado
Antes de qualquer coisa: parabéns, Filipe! Pelo conteúdo do curso, pela didática que transforma assuntos complexos em algo que dá vontade de colocar a mão na massa, e pelas palavras que sempre nos incentivam a ir para o próximo nível. Este post é, em boa parte, resultado desse incentivo. Não poderia esperar nada menos de você. Obrigado!
Estamos no módulo de IA, então resolvi encarar a corrida do Circuito 1 como um problema de engenharia: em vez de treinar o dedo, pedi ajuda a uma IA (Claude Code) para construir um piloto automático. A única regra que me impus: o carro só pode ser controlado pelas setas do teclado, como qualquer jogador. Nada de mexer na física, no timer ou no ranking.
Meu melhor tempo jogando na mão era 43,050s. O piloto chegou a 24,767s. Abaixo, o caminho, incluindo o que deu errado.
Ferramentas usadas
- Claude Code (IA agente), conduzindo tudo.
- Extensão Claude in Chrome, que deixa a IA abrir abas, clicar, tirar screenshots e executar JavaScript na página.
- JavaScript injetado no console, para ler o estado do jogo e "apertar" as teclas.
- Three.js: o jogo é uma cena 3D, e foi daí que saíram a posição do carro e o desenho da pista.
1. Fazer a IA "enxergar" o jogo
Na página não há uma variável global com o estado do jogo. A cena 3D fica fechada dentro do bundle. A saída foi uma armadilha: antes de abrir a corrida, defini um setter em Object.prototype para a propriedade isScene. Toda cena do Three.js faz this.isScene = true no construtor, então, quando o jogo cria a cena, ela "cai" na armadilha e fica guardada:
Object.defineProperty(Object.prototype, 'isScene', {
configurable: true,
set(v) {
Object.defineProperty(this, 'isScene', { value: v, writable: true, configurable: true });
window.__cap.scenes.push(this);
},
});
Com a cena em mãos:
- o carro é um
Group com posição (x, z) e rotação y;
- a pista é a malha do asfalto: cada par de vértices é a borda interna e a externa. A média dos dois dá a linha central. É um oval de ~960 × 460 unidades com 60 de largura.
Para controlar o carro bastou disparar KeyboardEvent de ArrowUp/Down/Left/Right. Um teste mostrou que → diminui o ângulo do carro e que ele anda na direção (sin θ, cos θ).
2. Primeira versão: seguir a linha central
O controlador mais simples possível (pure pursuit):
- a cada quadro, acha o ponto da pista mais próximo do carro;
- mira num ponto mais à frente (quanto mais rápido, mais longe);
- se o alvo está à esquerda, ←; à direita, →;
- tira o pé se o erro de direção for grande.
Resultado: 32,067s. Já era 11s melhor que eu, mas a telemetria mostrou o problema: em todas as curvas o carro chegava a ~210, batia no muro externo e caía para ~10.
3. Aprender com a telemetria
A partir daqui o método foi sempre o mesmo: gravar cada quadro (tempo, posição, ângulo, velocidade, distância até o traçado e teclas apertadas), analisar e ajustar. Foi assim que o piloto "aprendeu":
| O que os dados mostraram | O que mudou | Tempo |
|---|
| Bate nas curvas por chegar rápido demais | Velocidade-alvo calculada pela curvatura da pista à frente, com frenagem antecipada | 31,533s (achei um bug: a velocidade medida ficava em zero) |
| O carro freava sozinho na reta de chegada | Era um artefato: na emenda onde a pista "fecha o laço" havia pontos duplicados, e o cálculo via uma curva falsa. Removi os duplicados. | — |
| Na linha central as curvas ficam fechadas (raio ~140) | Traçado de corrida: otimizei a linha para minimizar a curvatura, abrindo por fora e cortando por dentro. O raio mínimo subiu para ~210. | 27,100s |
| Ainda raspava o muro ao entrar rápido demais | Frear assim que passa 4 da velocidade-alvo (antes era 15) | 25,950s |
| Medindo o giro real: quanto mais rápido, menos o carro vira (~1,5 rad/s a 175 contra ~1,05 a 225) | Troquei o "giro fixo" por um modelo de giro em função da velocidade | 24,867s |
| Na largada as setas laterais ficavam piscando (volante "liga/desliga" com o carro quase parado) | 1,2s só acelerando e uma zona morta maior em baixa velocidade | 24,817s |
| Ainda havia folga nas curvas | Pequeno ajuste no limite de giro (1,45 → 1,47) | 24,767s |
A física medida pela telemetria:
- velocidade máxima de ~222;
- aceleração que diminui perto do máximo;
- virar não tira velocidade;
- encostar na zebra ou no muro, sim.
4. O que não funcionou (e o que isso ensinou)
- Abrir mais pela esquerda antes das curvas: a 22 do centro o carro raspava o muro, e a 17 deu 25,68s. Como cada cabeceira são duas curvas de 90° com uma retinha no meio, abrir mais quase não aumenta o raio (206 → 210) e tira a margem.
- Traçado colado por dentro (o mais curto): as curvas ficam fechadas demais e o carro precisa frear mais. Ficou mais lento.
- Um controlador de direção mais preciso (corrige direção e desvio lateral e já entra virando ao ver a curva): o desvio máximo caiu de 15 para 8,8, mas o tempo não melhorou (24,98s). Subindo a velocidade nas curvas, bateu.
- Queimar a largada: o jogo detecta e mostra "Queimou a largada!". Monitorando o semáforo:
- as 5 luzes acendem exatamente a cada 1,0s;
- o tempo entre a 5ª luz e o verde é aleatório (1,0s numa largada, 2,1s na outra);
- o timer anda em quadros de 1/60s.
O ganho possível foi reagir no instante em que as luzes apagam (via MutationObserver), em vez de esperar o timer mudar, o que tira ~1 quadro. Na prática, some na variação entre corridas.
5. Onde parou
O piloto se estabilizou entre 24,77s e 24,98s. Ele já passa quase a corrida toda acelerando: só ~1s sem acelerar e ~0,13s freando em 25s. Para chegar nos 24,4s dos líderes, ele teria que fazer as curvas mais rápido sem bater, e não consegui achar como fazer isso com essa física.
Uma escolha consciente: não alterei nenhum valor do jogo (velocidade máxima, giro, timer). Pela forma como o jogo é carregado, isso provavelmente seria possível pelo console, mas aí o tempo deixaria de ser comparável com o de quem jogou. Se for mesmo possível, fica o aviso para quem cuida do ranking.
Resumo da evolução
43,050s (eu, na mão) → 32,067s (seguir o centro) → 27,100s (traçado otimizado) → 25,950s (frear na hora certa) → 24,867s (modelo de giro) → 24,767s (largada + ajuste fino)
O mais interessante não foi o tempo final, foi o processo: observar → medir → formular uma hipótese → testar, com a IA fazendo o trabalho pesado e eu decidindo a direção. Inclusive nas ideias que não deram certo.