GameEngineBench: Evaluating Coding Agents on Real C++ Runtime Environments

Resumo Técnico: GameEngineBench

Declaração do Problema

Os benchmarks atuais para agentes de codificação concentram-se predominantemente em tarefas de engenharia de software de propósito geral, como síntese de funções isoladas (ex: HumanEval, MBPP) ou resolução de problemas em repositórios padrão (ex: SWE-bench). Essas avaliações frequentemente falham em capturar as complexidades de sistemas interativos, em tempo real e com estado, onde a correção depende não apenas da semântica da linguagem, mas também de comportamentos de tempo de execução, como redes, ciclos de vida de objetos, callbacks de engine e gerenciamento de assets.

Especificamente, há uma carência de benchmarks que avaliem edições nativas de C++ com escopo definido dentro de projetos de motores de jogo funcionais. Nesses ambientes, um patch pode compilar e parecer sintaticamente correto, mas falhar devido a:

• Atualizar apenas o estado local em vez do estado autoritativo do servidor.
• Omitir transições críticas de ciclo de vida de objetos (ex: destruição, coleta de lixo).
• Quebrar interações com sistemas de gameplay existentes (ex: replicação, atualizações de UI, inicialização de subsistemas).

O desenvolvimento de jogos, particularmente utilizando motores maduros como o Unreal Engine, oferece um banco de testes prático para esses desafios porque os repositórios são executáveis, possuem estado e estão disponíveis publicamente, mas exigem integração profunda com arquiteturas de tempo de execução complexas.

Metodologia

Design do Benchmark (GameEngineBench)

Os autores introduzem o GameEngineBench, um benchmark composto por 110 tarefas derivadas de nove repositórios de código aberto do Unreal Engine 5 do mundo real (ex: HordeTemplateV2Native, ActionRoguelike, GASShooter).

• Estrutura da Tarefa: Cada tarefa fornece ao modelo um estado inicial compilável, uma lista específica de arquivos C++ editáveis e uma especificação de comportamento baseada em texto.
• Escopo: As tarefas abrangem diversas áreas, incluindo mecânicas de gameplay, comportamento multiplayer, IA, animação, UI, persistência, serialização de dados, XR e plugins de renderização.
• Restrições: Os modelos são restritos a editar arquivos de código-fonte C++ nativos. Embora os projetos possam utilizar assets não relacionados a código durante a execução, as edições testadas são estritamente baseadas em código.

Protocolo de Avaliação

O processo de avaliação é projetado para evitar o vazamento da lógica de teste e para avaliar a correção comportamental em vez da similaridade de referência.

1. Calibração de Tarefas: Antes da inclusão, as tarefas passam por uma validação de múltiplas etapas:
   • Validação de Teste: Garante que o projeto compile, que a solução de referência passe e que o estado inicial falhe nos comportamentos pretendidos.
   • Revisão por LLM-as-a-Judge: Um modelo de codificação forte tenta realizar a tarefa, e um juiz LLM revisa o resultado contra a especificação de comportamento para identificar testes subespecificados ou excessivamente restritos.
2. Execução:
   • Os modelos resolvem as tarefas em um espaço de trabalho temporário isolado.
   • Compilação: O projeto modificado deve compilar com sucesso.
   • Teste de Tempo de Execução: Os testes são injetados e executados via automação Play-in-Editor (PIE) do Unreal em modo listen-server. Isso simula um ambiente servidor-cliente para verificar autoridade, replicação e correção de ciclo de vida.
3. Julgamento:
   • Métrica Primária: Pass@1 (a fração de tarefas resolvidas por uma única tentativa).
   • Juiz: Um juiz LLM determina o sucesso com base em se a implementação satisfaz o comportamento solicitado, considerando resultados de execução, falhas de asserção e a solução de referência. O juiz não verifica meramente a similaridade de código, mas avalia se o comportamento em tempo de execução está correto.
   • Mitigação de Viés: O protocolo suporta julgamento entre famílias de modelos para reduzir o viés de auto-julgamento.

Principais Contribuições

1. Um Novo Benchmark para Desenvolvimento C++ Integrado: O GameEngineBench introduz 110 tarefas que exigem mudanças em C++ que devem se integrar a projetos funcionais de Unreal Engine. Diferente de benchmarks anteriores, ele avalia o código dentro de um contexto de execução ao vivo envolvendo redes, ciclos de vida de objetos e subsistemas.
2. Protocolo de Avaliação Centrado no Comportamento: Os autores definem um protocolo que combina edições de arquivos com escopo, execução em tempo de execução (PIE) e auditoria por juiz LLM. Isso desloca a métrica de avaliação de "ele compila?" ou "ele corresponde à referência?" para "ele se comporta corretamente na engine?".
3. Análise de Modos de Falha: O artigo fornece uma análise detalhada de por que os agentes de fronteira atuais falham, demonstrando que as baixas pontuações de pass@1 são impulsionadas por erros estruturados de tempo de execução e integração (ex: erros de autoridade, sincronização de estado, bugs de ciclo de vida) em vez de erros superficiais de sintaxe ou compilação.

Resultados

O benchmark foi avaliado em 12 configurações de modelos diferentes, incluindo modelos de fronteira como Claude 3.5/4 (Fable, Opus, Sonnet), GPT-4.5/5.5, Gemini 3.1 Pro, DeepSeek 4 e Qwen 3.7.

• Teto de Desempenho: O benchmark não está saturado. A configuração mais forte (Claude Fable-5 com esforço máximo de raciocínio) alcançou um pass@1 de 55,5%.
• Lacuna de Desempenho: Há uma lacuna significativa entre o melhor performer e os demais (ex: GPT-5.5 xhigh com 29,1%, Gemini 3.1 Pro com 18,2%).
• Tarefas Não Resolvidas: 31 tarefas (28%) permaneceram sem solução por qualquer uma das 12 configurações avaliadas.
• Complementaridade: Nenhuma configuração única resolveu todas as tarefas. Os conjuntos de tarefas resolvidas são complementares; diferentes modelos têm sucesso em diferentes subconjuntos, mas a seleção de modelos por si só não consegue cobrir todo o benchmark.
• Análise de Falhas:
  • Falhas de Compilação: Menos comuns entre os principais performers; a maioria das falhas ocorre pós-compilação.
  • Falhas de Comportamento: O principal modo de falha envolve a coordenação entre sistemas. Os modelos lutam para sincronizar identidade de atores, replicação, autoridade do servidor e eventos de ciclo de vida entre múltiplos subsistemas da engine.
  • Padrões Específicos: Erros comuns incluem manipulação incorreta de autoridade (executar lógica no cliente em vez do servidor), falta de hooks de replicação, gerenciamento incorreto do ciclo de vida de objetos (ex: tempo de limpeza) e integração incompleta com sistemas de jogo circundantes.

Significância e Alegações

O artigo afirma que o GameEngineBench serve como uma medida concreta da capacidade de agentes de codificação especificamente para o desenvolvimento de motores de jogo, um domínio que tem sido sub-representado em benchmarks de engenharia de software.

• Além da Sintaxe: Os resultados destacam que os agentes de codificação de fronteira lutam com o desenvolvimento C++ profundamente integrado para software interativo em tempo real. O sucesso exige compreender não apenas o código, mas o modelo de execução da engine, restrições de rede e gerenciamento de estado.
• Valor do Benchmark: Ao fundamentar as tarefas em projetos de jogos executáveis, o benchmark revela modos de falha (erros de integração em tempo de execução) que são invisíveis para benchmarks focados em funções isoladas ou revisão de código estática.
• Direção Futura: Os autores posicionam o GameEngineBench como uma fundação para avaliações mais abrangentes de programação dentro de motores de jogo. Eles observam que, embora o conjunto atual foque em sistemas C++ voltados para o gameplay, as futuras iterações devem expandir para incluir áudio, performance, segurança e código específico de plataforma para representar plenamente a engenharia de jogos profissional.

O artigo conclui que, embora os agentes atuais mostrem promessa, eles ainda não são confiáveis para a natureza complexa, estatal e integrada do desenvolvimento de motores de jogo de nível de produção, ressaltando a necessidade de benchmarks que testem o comportamento em tempo de execução e a integração de sistemas.