--- title: 'DX-Ball Reverse Engineering: Panning del suono-REA' url: https://rea.tools/it/showcase/dx-ball/ --- [Casa](https://rea.tools/it/) / [Vetrina](https://rea.tools/it/showcase/) / DX-Ball Caso di studio \* DX-Ball 1.07 # Ricostruzione DX-Ball dal suo eseguibile. L'obiettivo è una versione C mantenibile del gioco Windows del 1996. REA aiuta l'agente a ispezionare l'originale, una funzione alla volta. Windows i386 \* C \* REA ![DXBALL.La funzione EXE 0x00406400 è ispezionata con REA . Un chiamante brick-hit fornisce 20 più 30 volte tile_x. Istruzioni caricare x, moltiplicare per 1.5625, sottrarre 500.0, applicare pan_scale e restituire un numero intero. Il C mantenuto viene controllato indipendentemente dall'originale x86 in 3.205 casi e dal replay del compilatore VC4.0 che corrisponde a 63 byte.](https://rea.tools/assets/localized/it/figures/dx-ball-sound-pan-investigation.svg) Una funzione, dall'eseguibile al controllato C. REA fornisce le istruzioni, i chiamanti e le letture dei dati; il progetto di ricostruzione implementa e verifica il risultato. [Apri figura](https://rea.tools/assets/localized/it/figures/dx-ball-sound-pan-investigation.svg) 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](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/PROGRESS.md) · [Copertura di prova](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/ORACLES.md) ## 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. Il tuo agente di codifica Utilizzare REA per scoprire come DX-Ball calcola il posizionamento del suono stereo. Spiega il calcolo e mostra il codice. 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. La prima vista decompilatore Risultato REA \* estratto di pseudocodice ``` longlong FUN_00406400(void) { longlong lVar1; lVar1 = __ftol(); return lVar1; } ``` L'output mostra una chiamata di conversione. La lettura delle istruzioni riportate di seguito rivela l'input e il calcolo che alimenta quella chiamata. ### 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. Originale x86 \* estratto ``` 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 ``` Ricostruito 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 \* Leggere l'input.** La vista delle istruzioni nel risultato della funzione di REA legge `[EBP+8]` e usi `FILD` per caricare il numero intero. Seguendo il suo chiamante attraverso REA stabilisce il significato della coordinata dello schermo del parametro C `x`. **02 \* Moltiplicare per 1,5625.** `FMUL` legge il doppio a `0x420068`. I byte restituiti da REA `read_bytes` decodifica a `1.5625` C utilizza la stessa costante. **03 \* Sottrarre 500.0.** `FSUB` legge il doppio a `0x420070`. Il risultato byte di REA decodifica in `500.0`, spostando il centro del calcolo alla coordinata dello schermo `320`. **04 \* Applicare la scala memorizzata.** Secondo `FMUL` leggere `0x4210a0`. Questo globale è chiamato `dxball_pan_scale` nella fonte mantenuta. Il secondo byte letto di REA stabilisce il suo valore iniziale di `1.0`. **05 \* Restituisce un numero intero.** La chiamata a `0x406430` raggiungere `__ftol`, identificato nei risultati del callee di REA. Il C lancia il risultato a `DxBallInt`; originale-x86 confronti controllare il valore restituito. 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. Assemblea completa e prove a sostegno REA risultato \* 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 ``` ### Cosa fornisce il chiamante La funzione brick-hit a `0x411f40` ridimensiona la sua coordinata tile di 30, aggiunge 20, quindi la spinge prima della chiamata: ``` 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 ``` ### Ciò che i dati leggono stabiliscono REA byte legge, decodificato come little-endian raddoppia | Indirizzo | Valore | Usato per | | --- | --- | --- | | `0x420068` | `1.5625` | Prima moltiplicazione | | `0x420070` | `500.0` | Sottrazione | | `0x4210a0` | `1.0` inizialmente | Scala pan memorizzata | Registrato con REA 4.1.0 per il target DX-Ball 1.07 bloccato con hash. Le note di indagine collegate conservano gli ID delle prove. [Fonte mantenuta](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/src/gameplay.c#L41) · [Note di indagine e riferimenti alle prove](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/GAMEPLAY_OWNER.md) ## 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. ### 3.205 casi di comportamento I test eseguono la funzione x86 originale e confrontano il suo valore di ritorno con il C mantenuto.Coprono ogni posizione intera da 0 a 640 a cinque scale pan: 0, 0.5, 1, 20 e -1. ### 63 byte corrispondenti La funzione C è compilata con la toolchain VC4.0 bloccata. La riproduzione del compilatore corrisponde alla funzione completa dopo aver applicato le rilocazioni riviste e controllato le costanti di riferimento. 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](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/BUILD_MATCHING.md) ## 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: Nel checkout DX-Ball ``` scripts/rea function original/DXBALL.EXE 0x00406400 \ --snapshot .analysis/rea/dxball.snapshot.json --json ``` - [Archivio DX-Ball](https://github.com/N0zoM1z0/dx-ball)Fonte corrente, progresso e configurazione locale. - [Flusso di lavoro di analisi REA](https://rea.tools/guides/native/)Seguire il calcolo, quindi utilizzare lo stesso approccio con il proprio binario. - [Particelle e produzione di bonus](https://github.com/N0zoM1z0/dx-ball/blob/a55dca27ec0a07018c1b2c95ae2be027f7d8c3c4/docs/ENTITIES_OWNER.md)Un'indagine più ampia sullo stato, le code e le scritture dei pixel. [Inizia con il tuo obiettivo](https://rea.tools/get-started/)