---
title: 'DX-Ball engenharia reversa: panorâmica sonora-REA'
url: https://rea.tools/pt-BR/showcase/dx-ball/
---

[Casa](https://rea.tools/pt-BR/) / [Vitrines](https://rea.tools/pt-BR/showcase/) / DX-Ball

Estudo de caso \* DX-Ball 1.07

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

O objetivo é uma versão c sustentável do jogo Windows de 1996. REA ajuda o agente a inspecionar o original, uma função de cada vez.

Windows i386 \* C \* REA

![DXBALL.A função EXE 0x00406400 é inspeccionada com REA . Um chamador brick-hit fornece 20 mais 30 vezes tile_x. instruções carregue x, multiplique por 1,5625, subtraia 500,0, aplique pan_scale e retorne um inteiro. O C mantido é verificado independentemente em relação ao x86 original em 3.205 casos e por repetição do compilador VC4.0 correspondente a 63 bytes.](https://rea.tools/assets/localized/pt-BR/figures/dx-ball-sound-pan-investigation.svg)

Uma função, do executável ao verificado C. REA fornece as instruções, os chamadores e as leituras dos dados; o projecto de reconstrução implementa e testa o resultado. [Figura aberta](https://rea.tools/assets/localized/pt-BR/figures/dx-ball-sound-pan-investigation.svg)

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](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/PROGRESS.md) · [Cobertura do ensaio](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/ORACLES.md)

## 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.

O seu agente de codificação

Use o REA para descobrir como o DX-Ball calcula o posicionamento do som estéreo. Explique o cálculo e mostre o código.

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.

A primeira vista decompiladora

REA resultado \* excerto de pseudocódigo

```
longlong FUN_00406400(void)
{
  longlong lVar1;

  lVar1 = __ftol();
  return lVar1;
}
```

A saída mostra uma chamada de conversão. A leitura das instruções abaixo revela a entrada e o cálculo que alimentam essa chamada.

### 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.

Original x86 \* excerto

```
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
```

Reconstrução C

```
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;
}
```

**01 \* leia a entrada.** A visualização da instrução no resultado da função do REA diz `[EBP+8]` e utilizações `FILD` para carregar o número inteiro. Seguindo seu chamador através de REA estabelece o significado da coordenada de tela do parâmetro C `x`.

**02 \* multiplicar por 1,5625.** `FMUL` lê o duplo em `0x420068`. Os bytes devolvidos por REA `read_bytes` descodificar para `1.5625`; o C usa a mesma constante.

**03 \* subtrair 500.0.** `FSUB` lê o duplo em `0x420070`. O resultado do byte de REA descodifica para `500.0`, deslocando o centro do cálculo para coordenar a tela `320`.

**04 \* aplicar a balança armazenada.** O segundo `FMUL` lê `0x4210a0`. Esse global é nomeado `dxball_pan_scale` na fonte mantida. O segundo byte lido de REA estabelece o seu valor inicial de `1.0`.

**05 \* retorna um número inteiro.** A chamada em `0x406430` alcances `__ftol`, identificado nos resultados do receptor do REA. O C lança o resultado para `DxBallInt`; comparações originais-x86 verificam o valor devolvido.

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.

Conjunto completo e elementos de prova de apoio

REA resultado · 0x406400-0x40643e

```
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
```

### O que o chamador fornece

A função brick-hit em `0x411f40` dimensiona sua coordenada de bloco em 30, adiciona 20 e, em seguida, empurra-a antes da chamada:

```
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
```

### O que os dados indicam

REA Byte lê, decodificado como Little-Endian duplica

| Endereço | Valor | Usado para |
| --- | --- | --- |
| `0x420068` | `1.5625` | Primeira multiplicação |
| `0x420070` | `500.0` | Subtração |
| `0x4210a0` | `1.0` inicialmente | Escala armazenada da bandeja |

Gravado com REA 4.1.0 Para o alvo DX-Ball 1.07 fixado por hash. As notas de investigação conexas conservam os IDs dos elementos de prova.

[Fonte mantida](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/src/gameplay.c#L41) · [Notas de investigação e referências de elementos de prova](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/GAMEPLAY_OWNER.md)

## 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.

### 3.205 casos de comportamento

Os testes executam a função x86 original e comparam o seu valor de retorno com o C mantido.cobrem todas as posições inteiras de 0 a 640 em cinco escalas pan: 0, 0,5, 1, 20 e -1.

### 63 bytes correspondentes

A função C é compilada com o conjunto de ferramentas VC4.0 fixado. O replay do compilador corresponde à função completa após aplicar as relocações revisadas e verificar as constantes referenciadas.

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](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/BUILD_MATCHING.md)

## 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:

No checkout DX-Ball

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

- [Repositório DX-Ball](https://github.com/N0zoM1z0/dx-ball)Fonte actual, progresso e configuração local.
- [Fluxo de trabalho de análise REA](https://rea.tools/guides/native/)Siga o cálculo e, em seguida, use a mesma abordagem com seu próprio binário.
- [Partículas e produção de bónus](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/ENTITIES_OWNER.md)Uma investigação maior sobre Estado, filas e gravações de pixel.

[Comece com o seu próprio alvo](https://rea.tools/get-started/)