Reconstructing TH04's
bullet patterns.

How a ring aims at the player

Elly's attack requests an aimed ring with an initial count of 16. One helper calculates the direction of each bullet. The same ring can face a fixed direction or turn toward the player.

An example prompt, with the original executable and reconstruction checkout available locally.

TH04 stores a full clockwise turn in 256 angle units. For 16 bullets, each index adds 16 units: 0, 16, 32, …, 240. Adding the player's direction rotates those positions together.

The firing template in the recovered source

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

These lines select the pattern before difficulty and performance tuning. Read the attack's source.

What REA returns

We inspect bullet_velocity_and_angle_set(), the function that sets each bullet's velocity and angle. REA returns its instructions, pseudocode and references. Three parts of that result explain the pattern.

1. Check the DOS image before reading its code

   Agent → REA

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

   REA → agent · selected fields

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

   The check ties the loaded code and relocation records to the supplied executable. The path above is shortened for display.

2. Read the ring's multiply and divide

   Agent → REA · analyze_function

   {"procedure": "0x2cfc8"}

   REA → agent · instruction excerpt

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

   SI holds the bullet index. The shift multiplies it by 256, then the division uses the count read from DS:53AF. The maintained source names that field bullet_template.count. The complete sequence appears below.

3. Find where the pattern turns toward the player

   Same function result · aim excerpt

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

   Corresponding maintained C++

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

   The instruction operands expose two coordinate differences and a direction helper. Its return value is added to the relative ring angle. Source names make those addresses readable; REA lets the agent check the original operations behind them.

From assembly to readable C++

Select a step to match the original instructions with the angle calculation. This summary follows the aimed-ring path; the full source also handles spreads, stacks and random patterns.

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

The assembly selects the aimed-ring branch, aim calculation and final store. The C++ above is a readable summary. Compiler checks below apply to the maintained source in the linked project.

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

Checking the maintained source

The TH04 project's recorded checks compile the bullet-generation code, including this helper, with its pinned Turbo C++ 4.0J toolchain.

Recorded on 3 October 2026. Read the compiler checks.

The full TH04 reconstruction

The project builds the game's four DOS products from maintained C++ and assembly. Beyond bullet generation, the source covers stages, bosses, rendering, input, menus, endings and score handling.

Explore the TH04 repository

• Bullet-generation sourceThe complete helper, other pattern types and template tuning.
• DOS build and run guideBuild the source and test it in the project's PC-98 emulator workflow.
• Current project stateDOS verification and the separate native x64 port.