Reconstrução DX-Ball
do seu executável.

55

funções C mantidas

45,380

comparações com o código original

33

funções com correspondência de bytes compilados

Ponto de verificação do projeto: 7 de outubro de 2026. Razão de progresso · Cobertura do ensaio

O projecto até agora

O código recuperado abrange a manipulação de placas e recursos, batidas de tijolos, animações, partículas e produção de bônus. As compilações atuais fornecem utilitários de inspeção e uma biblioteca de análise. O trabalho no jogo jogável continua com física de bola e remo, manipulação de power-up e integração Windows.

Determinação do cálculo da posição sonora esquerda/direita

Quando um tijolo é atingido, a sua posição horizontal é passada para o código sonoro. A investigação necessária para recuperar a forma como essa coordenada de ecrã se torna um valor de panorâmica esquerda / direita.

Um exemplo de prompt para o seu agente de codificação, com o executável local disponível. A investigação que se segue mostra as questões REA e os elementos de prova subjacentes à resposta.

O agente usou REA para inspecionar a função, seguir seu chamador de tijolo e ler as constantes do executável. Esses resultados forneceram a entrada e a aritmética necessárias para escrever a função C abaixo.

O primeiro resultado da função para 0x406400 pseudocódigo incluído declarando FUN_00406400(void) e chamando __ftol(). Sua visão de instrução mostrou uma entrada de pilha e operações de ponto flutuante. Essa discrepância deu ao Agente uma razão concreta para continuar a investigar.

longlong FUN_00406400(void)
{
  longlong lVar1;

  lVar1 = __ftol();
  return lVar1;
}

Três perguntas respondidas através de REA

1. Recuperar a entrada em falta

   Agente REA · analyze_function

   {"procedure": "0x406400"}

   REA7 agente * excerto de instruções

   0x406409: MOV EAX, dword ptr [EBP + 0x8]
   0x40640c: MOV dword ptr [EBP + -0xc], EAX
   0x40640f: FILD dword ptr [EBP + -0xc]

   O resultado da função inclui instruções juntamente com pseudocódigo e chamadores. Aqui, [EBP+8] expõe a entrada inteira ausente da visualização decompiler.

2. Siga o chamador para entender a entrada

   Agente REA · analyze_function

   {"procedure": "0x411f40"}

   REA extraterritorial * excerto do autor da chamada

   0x411f5b: ADD EAX, 0x14
   0x411f5e: PUSH EAX
   0x411f5f: CALL 0x00406400

   REA identificou este autor da chamada no primeiro resultado. Escala das instruções anteriores tile_x por 30; adicionar 20 dá a coordenada da tela do tijolo, 20 + 30 × tile_x.

3. Ler os valores por detrás dos endereços de memória

   Agente REA * dois read_bytes pedidos

   {"address": "0x420068", "length": 16}
   {"address": "0x4210a0", "length": 8}

   Resultados do byte REA * descodificados como duplos

   000000000000f93f → 1.5625
   0000000000407f40 → 500.0
   000000000000f03f → 1.0

   Os bytes retornados estabelecem as duas constantes aritméticas e a escala pan inicial. O agente agora tem os valores necessários para a expressão C.

Das conclusões do REA até C

Siga os cinco passos abaixo. Cada seleção destaca as instruções originais e as linhas C que informaram.

0x406409: MOV EAX, dword ptr [EBP + 0x8]
0x40640c: MOV dword ptr [EBP + -0xc], EAX
0x40640f: FILD dword ptr [EBP + -0xc]
0x406415: FMUL double ptr [0x00420068]
0x40641e: FSUB double ptr [0x00420070]
0x406427: FMUL double ptr [0x004210a0]
0x406430: CALL 0x0041678c
0x40643e: RET

DxBallInt dxball_screen_pan(DxBallInt x)
{
    double pan;
    pan = (double)x;
    pan = pan * 1.5625;
    pan = pan - 500.0;
    pan = pan * dxball_pan_scale;
    return (DxBallInt)pan;
}

O excerto de montagem seleciona as instruções de entrada, aritmética e retorno. A lista completa abaixo também inclui os armazenamentos intermediários e a configuração e limpeza de funções.

0x406400: PUSH EBP
0x406401: MOV EBP, ESP
0x406403: SUB ESP, 0xc
0x406406: PUSH EBX
0x406407: PUSH ESI
0x406408: PUSH EDI
0x406409: MOV EAX, dword ptr [EBP + 0x8]
0x40640c: MOV dword ptr [EBP + -0xc], EAX
0x40640f: FILD dword ptr [EBP + -0xc]
0x406412: FST double ptr [EBP + -0x8]
0x406415: FMUL double ptr [0x00420068]
0x40641b: FST double ptr [EBP + -0x8]
0x40641e: FSUB double ptr [0x00420070]
0x406424: FST double ptr [EBP + -0x8]
0x406427: FMUL double ptr [0x004210a0]
0x40642d: FST double ptr [EBP + -0x8]
0x406430: CALL 0x0041678c
0x406435: JMP 0x0040643a
0x40643a: POP EDI
0x40643b: POP ESI
0x40643c: POP EBX
0x40643d: LEAVE
0x40643e: RET

0x411f50: MOV EAX, dword ptr [EBP + 0x8]
0x411f53: ADD EAX, EAX
0x411f55: LEA EAX, [EAX + EAX*0x2]
0x411f58: LEA EAX, [EAX + EAX*0x4]
0x411f5b: ADD EAX, 0x14
0x411f5e: PUSH EAX
0x411f5f: CALL 0x00406400
0x411f64: ADD ESP, 0x4

Fonte mantida · Notas de investigação e referências de elementos de prova

Verificação da função recuperada

A função recuperada passa por duas verificações: seus valores de retorno correspondem ao original e seus bytes compilados correspondem ao executável.

Em uma escala de 1, o cálculo recuperado retorna -500 na borda esquerda, 0 no centro e 500 na borda direita. A próxima parte do trabalho de áudio é integrar esse valor com o back-end de som do jogo.

Leia os detalhes do replay do compilador

Prosseguir o inquérito

A mesma abordagem está a ser utilizada para actualizações de partículas, filas de explosão e geração de bónus: inspeccionar as funções relevantes, recuperar o seu estado e dependências e, em seguida, comparar a implementação com a original.

Para inspecionar você mesmo a função sound-pan, siga as instruções de configuração do projeto DX-Ball e forneça seu alvo original correspondente. Em seguida, execute:

scripts/rea function original/DXBALL.EXE 0x00406400 \
  --snapshot .analysis/rea/dxball.snapshot.json --json

• Repositório DX-BallFonte actual, progresso e configuração local.
• Fluxo de trabalho de análise REASiga o cálculo e, em seguida, use a mesma abordagem com seu próprio binário.
• Partículas e produção de bónusUma investigação maior sobre Estado, filas e gravações de pixel.