Ricostruzione DX-Ball
dal suo eseguibile.

55

funzioni C mantenute

45,380

confronto con il codice originale

33

funzioni con byte compilati corrispondenti

Checkpoint del progetto: 7 ottobre 2026. Progress ledger · Copertura di prova

Il progetto finora

Il codice recuperato copre bordo e la gestione delle risorse, colpi di mattoni, animazioni, particelle e la produzione di bonus. Le build correnti forniscono utilità di ispezione e una libreria di analisi. Il lavoro sul gioco giocabile continua con la fisica della palla e della pagaia, la gestione dei potenziamenti e l'integrazione con Windows.

Trovare il calcolo della posizione del suono sinistra/destra

Quando un mattone viene colpito, la sua posizione orizzontale viene passata al codice audio. L'indagine era necessaria per recuperare il modo in cui quella coordinata dello schermo diventa un valore di panning sinistro/destro.

Un prompt di esempio per l'agente di codifica, con l'eseguibile locale disponibile. L'indagine di seguito mostra le query REA e le prove dietro la risposta.

L'agente ha utilizzato REA per ispezionare la funzione, seguire il suo chiamante brick-hit e leggere le costanti dall'eseguibile. Questi risultati hanno fornito l'input e l'aritmetica necessari per scrivere la funzione C qui sotto.

Il primo risultato della funzione per 0x406400 dichiarazione pseudocodice inclusa FUN_00406400(void) e chiamando __ftol(). La sua vista delle istruzioni mostrava un input dello stack e operazioni in virgola mobile. Questa discrepanza ha dato all'agente un motivo concreto per continuare a indagare.

longlong FUN_00406400(void)
{
  longlong lVar1;

  lVar1 = __ftol();
  return lVar1;
}

Tre domande risposte attraverso REA

1. Recuperare l'input mancante

   Agente → REA · analyze_function

   {"procedure": "0x406400"}

   REA → agente * estratto di istruzioni

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

   Il risultato della funzione include istruzioni insieme a pseudocodice e chiamanti. Qui, [EBP+8] espone l'input intero mancante dalla vista decompiler.

2. Seguire il chiamante per capire l'input

   Agente → REA · analyze_function

   {"procedure": "0x411f40"}

   REA → agente * estratto del chiamante

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

   REA ha identificato questo chiamante nel primo risultato. Le sue istruzioni precedenti scala tile_x con 30; l'aggiunta di 20 dà la coordinata dello schermo del mattone, 20 + 30 × tile_x.

3. Leggere i valori dietro gli indirizzi di memoria

   Agente → REA * due read_bytes richiesta

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

   Risultati byte REA * decodificati come doppi

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

   I byte restituiti stabiliscono le due costanti aritmetiche e la scala pan iniziale. L'agente ora ha i valori necessari per l'espressione C.

Dai risultati di REA a C

Segui i cinque passaggi seguenti. Ogni selezione evidenzia le istruzioni originali e le linee C che hanno informato.

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

L'estratto dell'assembly seleziona le istruzioni di input, aritmetica e ritorno. L'elenco completo di seguito include anche i negozi intermedi e l'impostazione e la pulizia delle funzioni.

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 mantenuta · Note di indagine e riferimenti alle prove

Controllo della funzione recuperata

La funzione recuperata passa due controlli: i suoi valori di ritorno corrispondono all'originale e i suoi byte compilati corrispondono all'eseguibile.

In una scala di 1, il calcolo recuperato restituisce -500 sul bordo sinistro, 0 al centro e 500 sul bordo destro. La parte successiva del lavoro audio è l'integrazione di tale valore con il back-end audio del gioco.

Leggi i dettagli di riproduzione del compilatore

Continua l'indagine

Lo stesso approccio viene utilizzato per gli aggiornamenti delle particelle, le code di esplosione e la generazione di bonus: ispezionare le funzioni pertinenti, recuperare il loro stato e le dipendenze, quindi confrontare l'implementazione con l'originale.

Per ispezionare personalmente la funzione sound-pan, seguire le istruzioni di installazione del progetto DX-Ball e fornire il relativo target originale corrispondente. Allora corri:

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

• Archivio DX-BallFonte corrente, progresso e configurazione locale.
• Flusso di lavoro di analisi REASeguire il calcolo, quindi utilizzare lo stesso approccio con il proprio binario.
• Particelle e produzione di bonusUn'indagine più ampia sullo stato, le code e le scritture dei pixel.