Ricostruzione di TH04
modelli di proiettile.

Come un anello mira al giocatore

L'attacco di Elly richiede un anello mirato con un conteggio iniziale di 16. Un aiutante calcola la direzione di ogni proiettile. Lo stesso anello può affrontare una direzione fissa o girare verso il giocatore.

Un prompt di esempio, con l'eseguibile originale e il checkout di ricostruzione disponibili localmente.

TH04 memorizza una rotazione completa in senso orario in 256 unità angolari. Per 16 punti, ogni indice aggiunge 16 unità: 0, 16, 32, …, 240. Aggiungendo la direzione del giocatore ruota insieme quelle posizioni.

Il modello di cottura nella fonte recuperata

bullet_template.angle = 0;
bullet_template.group = BG_RING_AIMED;
bullet_template.count = 16;
bullet_template_tune();

Queste linee selezionano il modello prima della difficoltà e della messa a punto delle prestazioni. Leggi la fonte dell'attacco.

Cosa restituisce REA

Controlliamo bullet_velocity_and_angle_set(), la funzione che imposta la velocità e l'angolo di ogni proiettile. REA restituisce le sue istruzioni, pseudocodice e riferimenti. Tre parti di questo risultato spiegano il modello.

1. Controllare l'immagine DOS prima di leggere il suo codice

   Agente → REA

   open_binary
   {"path": "MAIN.EXE"}
   
   inspect_native_load_image
   {}

   REA → agente * campi selezionati

   status: "verified"
   format: "dos-mz"
   load_segment: 4096
   header_bytes: 6144
   module_bytes: 150114

   Il controllo lega il codice caricato e i record di rilocazione all'eseguibile fornito. Il percorso sopra è abbreviato per la visualizzazione.

2. Leggi l'anello moltiplica e dividi

   Agente → REA · analyze_function

   {"procedure": "0x2cfc8"}

   REA → agente * estratto di istruzioni

   0x2d0eb: MOV AX, SI
   0x2d0ed: SHL AX, 0x8
   0x2d0f0: MOV DL, byte ptr [0x53af]
   0x2d0f9: IDIV BX

   SI contiene l'indice proiettile. Lo spostamento lo moltiplica per 256, quindi la divisione utilizza il conteggio letto da DS:53AF. I nomi di origine mantenuti quel campo bullet_template.count. La sequenza completa appare sotto.

3. Trova dove il modello gira verso il giocatore

   Stesso risultato di funzione * estratto aim

   0x2d190: SUB AX, word ptr [0x53a6]
   0x2d198: SUB AX, word ptr [0x53a4]
   0x2d19d: CALLF 0x1000:1da8
   0x2d1a2: ADD word ptr [BP + -0x2], AX

   Corrispondente mantenuto C++

   group_angle_offset += iatan2(
     player_pos.cur.y - bullet_template.origin.y,
     player_pos.cur.x - bullet_template.origin.x
   );

   Gli operandi di istruzione espongono due differenze di coordinate e un assistente di direzione. Il suo valore di ritorno viene aggiunto all'angolo dell'anello relativo. I nomi di origine rendono leggibili quegli indirizzi; REA consente all'agente di controllare le operazioni originali dietro di loro.

Dall'assembly al C++leggibile

Selezionare un passaggio che corrisponda alle istruzioni originali con il calcolo dell'angolo. Questo riepilogo segue il percorso dell'anello mirato; la fonte completa gestisce anche spread, stack e modelli casuali.

0x2cfcf: MOV SI, word ptr [BP + 0x4]
0x2d0eb: MOV AX, SI
0x2d0ed: SHL AX, 0x8
0x2d0f0: MOV DL, byte ptr [0x53af]
0x2d0f4: MOV DH, 0x0
0x2d0f6: PUSH DX
0x2d0f7: CWD
0x2d0f8: POP BX
0x2d0f9: IDIV BX
0x2d0fb: MOV word ptr [BP + -0x2], AX
0x2d18d: MOV AX, [0x4650]
0x2d190: SUB AX, word ptr [0x53a6]
0x2d194: PUSH AX
0x2d195: MOV AX, [0x464e]
0x2d198: SUB AX, word ptr [0x53a4]
0x2d19c: PUSH AX
0x2d19d: CALLF 0x1000:1da8
0x2d1a2: ADD word ptr [BP + -0x2], AX
0x2d1b9: MOV AL, byte ptr [BP + -0x2]
0x2d1bc: ADD AL, byte ptr [0x53ad]
0x2d1c0: MOV [0xbcc8], AL

unsigned char aimed_ring_angle(
    int index, int count,
    int player_direction,
    unsigned char rotation)
{
    int angle = index;
    angle = (angle * 256) / count;
    angle += player_direction;
    angle += rotation;
    return (unsigned char)angle;
}

L'assemblaggio seleziona il ramo dell'anello di mira, il calcolo dell'obiettivo e l'archivio finale. Il C++ sopra è un riassunto leggibile. I controlli del compilatore riportati di seguito si applicano all'origine mantenuta nel progetto collegato.

angle_offset = (i * BULLET_ANGLE_FULL_TURN) / count;
if (i >= (count - 1)) {
    group_complete = true;
}
goto aim_or_no_aim;

aim:
    group_angle_offset += iatan2(
        (player_pos.cur.y - bullet_template.origin.y),
        (player_pos.cur.x - bullet_template.origin.x)
    );

no_aim:
    vector2_near(
        bullet_template.velocity,
        (group_angle_offset + bullet_template.angle),
        speed
    );
    bullet_spawn_angle = (group_angle_offset + bullet_template.angle);

Verifica della fonte mantenuta

I controlli registrati del progetto TH04 compilano il codice di generazione bullet, incluso questo helper, con la sua toolchain Turbo C++ 4.0 J bloccata.

Registrato il 3 ottobre 2026. Leggi i controlli del compilatore.

La ricostruzione completa TH04

Il progetto costruisce quattro prodotti DOS del gioco da mantenuto C++ e assembly. Oltre alla generazione di proiettili, la fonte copre fasi, boss, rendering, input, menu, finali e gestione dei punteggi.

Esplora il repository TH04

• Fonte di generazione di proiettiliL'helper completo, altri tipi di pattern e template tuning.
• DOS costruire ed eseguire guidaCrea il sorgente e testalo nel flusso di lavoro dell'emulatore PC-98 del progetto.
• Stato attuale del progettoVerifica DOS e la porta x64 nativa separata.