DX-Ball Ingeniería inversa: Panorámica de sonido-REA

55: funciones C mantenidas
45,380: comparaciones con el código original
33: funciones con bytes compilados coincidentes

Punto de control del proyecto: 7 de octubre de 2026. Libro de progreso · Cobertura de la prueba

El proyecto hasta ahora

El código recuperado cubre el manejo de tableros y recursos, golpes de ladrillos, animaciones, partículas y producción de bonificaciones. Las compilaciones actuales proporcionan utilidades de inspección y una biblioteca de análisis. El trabajo en el juego jugable continúa con la física de la pelota y la paleta, el manejo del encendido y la integración Windows.

Encontrar el cálculo de la posición del sonido izquierda/derecha

Cuando se golpea un ladrillo, su posición horizontal pasa al código de sonido. La investigación necesaria para recuperar cómo esa coordenada de pantalla se convierte en un valor de panorámica izquierda/derecha.

Su agente de codificación

Use REA para averiguar cómo DX-Ball calcula el posicionamiento del sonido estéreo. Explique el cálculo y muestre el código.

Un mensaje de ejemplo para su agente de codificación, con el ejecutable local disponible. La investigación a continuación muestra las consultas REA y la evidencia detrás de la respuesta.

El agente usó REA para inspeccionar la función, seguir a la persona que llamó y leer las constantes del ejecutable. Esos resultados proporcionaron la entrada y la aritmética necesarias para escribir la función C a continuación.

El resultado de la primera función para 0x406400 declaración de pseudocódigo incluida FUN_00406400(void) y llamando __ftol(). Su vista de instrucciones mostraba una entrada de pila y operaciones de coma flotante. Esa discrepancia le dio al agente una razón concreta para seguir investigando.

La primera vista del descompilador

REA resultado * extracto de pseudocódigo

longlong FUN_00406400(void)
{
  longlong lVar1;

  lVar1 = __ftol();
  return lVar1;
}

La salida muestra una llamada de conversión. Al leer las instrucciones a continuación, se revela la entrada y el cálculo que alimenta esa llamada.

Tres preguntas respondidas a través de REA

Recuperar la entrada faltante
Agente → REA · analyze_function
```
{"procedure": "0x406400"}
```
REA → extracto de instrucciones del agente ·
```
0x406409: MOV EAX, dword ptr [EBP + 0x8]
0x40640c: MOV dword ptr [EBP + -0xc], EAX
0x40640f: FILD dword ptr [EBP + -0xc]
```
El resultado de la función incluye instrucciones junto con el pseudocódigo y las personas que llaman. Aquí, [EBP+8] expone la entrada entera que falta en la vista del descompilador.
Siga a la persona que llama para comprender la entrada
Agente → REA · analyze_function
```
{"procedure": "0x411f40"}
```
REA → extracto del agente * llamante
```
0x411f5b: ADD EAX, 0x14
0x411f5e: PUSH EAX
0x411f5f: CALL 0x00406400
```
REA identificó a esta persona que llamó en el primer resultado. Su escala de instrucciones anteriores tile_x por 30; sumando 20 da la coordenada de la pantalla del ladrillo, 20 + 30 × tile_x.
Leer los valores detrás de las direcciones de memoria
Agente → REA * dos read_bytes solicitudes
```
{"address": "0x420068", "length": 16}
{"address": "0x4210a0", "length": 8}
```
Resultados de bytes REA * decodificados como dobles
```
000000000000f93f → 1.5625
0000000000407f40 → 500.0
000000000000f03f → 1.0
```
Los bytes devueltos establecen las dos constantes aritméticas y la escala panorámica inicial. El agente ahora tiene los valores necesarios para la expresión C.

De los hallazgos de REA a C

Siga los cinco pasos a continuación. Cada selección resalta las instrucciones originales y las líneas C que informaron.

Original x86 · extracto

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

Reconstruido 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 * Lea la entrada. La vista de instrucciones en el resultado de la función REA dice [EBP+8] y usos FILD para cargar el entero. Seguir a su llamador a través de REA establece el significado de la coordenada de pantalla del parámetro C x.

02 * Multiplica por 1.5625. FMUL lee el doble en 0x420068. Los bytes devueltos por REA read_bytes decodificar a 1.5625; la C usa la misma constante.

03 * Resta 500.0. FSUB lee el doble en 0x420070. El resultado de bytes de REA se decodifica en 500.0, cambiando el centro del cálculo a coordenadas de pantalla 320.

04 * Aplique la báscula almacenada. El segundo FMUL lecturas 0x4210a0. Ese global se llama dxball_pan_scale en la fuente mantenida. La lectura del segundo byte de REA establece su valor inicial de 1.0.

05 * Devuelve un número entero. La llamada al 0x406430 alcances __ftol, identificado en los resultados de llamadas de REA. La C arroja el resultado a DxBallInt; original-las comparaciones x86 verifican el valor devuelto.

El extracto de la asamblea selecciona las instrucciones de entrada, aritmética y retorno. La lista completa a continuación también incluye las tiendas intermedias y la configuración y limpieza de funciones.

Montaje completo y pruebas de apoyo

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

Lo que suministra la persona que llama

La función de golpe de ladrillo en 0x411f40 escala su coordenada de mosaico en 30, agrega 20 y luego la empuja antes de la llamada:

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

Lo que establecen las lecturas de los datos

Lecturas de bytes REA, decodificadas como dobles little-endian
Dirección	Valor	Utilizado para
`0x420068`	`1.5625`	Primera multiplicación
`0x420070`	`500.0`	Resta
`0x4210a0`	`1.0` inicialmente	Escala de pan almacenada

Grabado con REA 4.1.0 para el objetivo DX-Ball 1.07 fijado con hash. Las notas de investigación vinculadas conservan las identificaciones de las pruebas.

Fuente mantenida · Notas de investigación y referencias de evidencia

Comprobando la función recuperada

La función recuperada pasa dos comprobaciones: sus valores de retorno coinciden con el original y sus bytes compilados coinciden con el ejecutable.

3.205 casos de conducta

Las pruebas ejecutan la función x86 original y comparan su valor de retorno con la C mantenida. Cubren cada posición entera de 0 a 640 en cinco escalas panorámicas: 0, 0.5, 1, 20 y -1.

63 bytes coincidentes

La función C se compila con la cadena de herramientas VC4.0 anclada. La repetición del compilador coincide con la función completa después de aplicar las reubicaciones revisadas y verificar las constantes a las que se hace referencia.

En una escala de 1, el cálculo recuperado devuelve -500 en el borde izquierdo, 0 en el centro y 500 en el borde derecho. La siguiente parte del trabajo de audio es integrar ese valor con el backend de sonido del juego.

Lea los detalles de la repetición del compilador

Continuar la investigación

El mismo enfoque se está utilizando para las actualizaciones de partículas, las colas de explosión y la generación de bonificaciones: inspeccione las funciones relevantes, recupere su estado y dependencias, luego compare la implementación con la original.

Para inspeccionar la función de panorámica de sonido usted mismo, siga las instrucciones de configuración del proyecto DX-Ball y proporcione su objetivo original correspondiente. Entonces corre:

En la caja de DX-Ball

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

Repositorio DX-BallFuente actual, progreso y configuración local.
Flujo de trabajo de análisis REASiga el cálculo, luego use el mismo enfoque con su propio binario.
Partículas y producción de bonosUna investigación más amplia sobre el estado, las colas y las escrituras de píxeles.

Comience con su propio objetivo

Reconstruyendo DX-Ball desde su ejecutable.