u/CryptFallGame

CryptFall is a bullet-hell roguelite I'm building solo in Rust/Bevy. This patch added a phase-2-only "heavy attack" to every boss — a much bigger, longer-charging strike than their normal shots. The interesting part wasn't the attack itself, it was realizing I already had everything I needed to telegraph it.


Bosses already had two telegraph components from an earlier pass — a warning system that gives players a beat's notice before any attack fires:


```rust
struct AttackTelegraphRing { timer: f32, max_lifetime: f32, end_size: f32 }
struct AttackTelegraphLine { timer: f32, max_lifetime: f32 }
```


Both fields are per-instance, not hardcoded constants — `timer`/`max_lifetime` live on the spawned entity, not baked into the type. That meant when I needed a 
*much*
 longer, 
*much*
 bigger telegraph for the new heavy attacks (1.0–1.6s charge-up depending on the boss, vs. a fraction of a second for a normal shot), I didn't need a new component or a new rendering system — just a different call:


```rust
spawn_heavy_telegraph(&mut commands, &textures, origin, player_pos, def.heavy_charge_time);
```


Same ring, same line, just a longer `max_lifetime`, a bigger `end_size`, and a hot-amber tint instead of the standard red — enough to make "this is different, and bigger" read instantly without a single new asset.


The attacks themselves are plain function pointers on each boss's data-driven definition:


```rust
pub heavy_attack: Option<fn(&mut Commands, &TextureAssets, Vec2, Vec2, f32)>,
pub heavy_cd_range: [f32; 2],
pub heavy_charge_time: f32,
```


`None` means that boss doesn't have one yet — adding a new heavy attack to an existing boss, or giving a totally new boss one, is a data change in one array literal, not a new system. The AI loop just checks `if let Some(f) = def.heavy_attack` and calls it — no branching on which boss it is anywhere in the actual logic.


One small deliberate quirk: the cooldown re-rolls to a random value in `heavy_cd_range` after every shot (instead of a fixed cadence), specifically so the attack can't be timed or memorized — a data field, not a special case in the AI code.


Total new code for the feature: one new function (`spawn_heavy_telegraph`), one new AI branch, and a few new fields per boss definition. No new components, no new rendering path. The lesson that's stuck with me building this: when I go to add a "bigger" version of something that already exists, the first question is whether the existing thing was already parameterized enough to just be called differently — more often than I expect, it was.


CryptFall's on itch.io if anyone wants to see it in motion: [https://mobtv.itch.io/cryptfall]**How CryptFall's boss "heavy attack" telegraphs work — reusing components instead of building new ones**


CryptFall is a bullet-hell roguelite I'm building solo in Rust/Bevy. This patch added a phase-2-only "heavy attack" to every boss — a much bigger, longer-charging strike than their normal shots. The interesting part wasn't the attack itself, it was realizing I already had everything I needed to telegraph it.


Bosses already had two telegraph components from an earlier pass — a warning system that gives players a beat's notice before any attack fires:


```rust
struct AttackTelegraphRing { timer: f32, max_lifetime: f32, end_size: f32 }
struct AttackTelegraphLine { timer: f32, max_lifetime: f32 }
```


Both fields are per-instance, not hardcoded constants — `timer`/`max_lifetime` live on the spawned entity, not baked into the type. That meant when I needed a *much* longer, *much* bigger telegraph for the new heavy attacks (1.0–1.6s charge-up depending on the boss, vs. a fraction of a second for a normal shot), I didn't need a new component or a new rendering system — just a different call:


```rust
spawn_heavy_telegraph(&mut commands, &textures, origin, player_pos, def.heavy_charge_time);
```


Same ring, same line, just a longer `max_lifetime`, a bigger `end_size`, and a hot-amber tint instead of the standard red — enough to make "this is different, and bigger" read instantly without a single new asset.


The attacks themselves are plain function pointers on each boss's data-driven definition:


```rust
pub heavy_attack: Option<fn(&mut Commands, &TextureAssets, Vec2, Vec2, f32)>,
pub heavy_cd_range: [f32; 2],
pub heavy_charge_time: f32,
```


`None` means that boss doesn't have one yet — adding a new heavy attack to an existing boss, or giving a totally new boss one, is a data change in one array literal, not a new system. The AI loop just checks `if let Some(f) = def.heavy_attack` and calls it — no branching on which boss it is anywhere in the actual logic.


One small deliberate quirk: the cooldown re-rolls to a random value in `heavy_cd_range` after every shot (instead of a fixed cadence), specifically so the attack can't be timed or memorized — a data field, not a special case in the AI code.


Total new code for the feature: one new function (`spawn_heavy_telegraph`), one new AI branch, and a few new fields per boss definition. No new components, no new rendering path. The lesson that's stuck with me building this: when I go to add a "bigger" version of something that already exists, the first question is whether the existing thing was already parameterized enough to just be called differently — more often than I expect, it was.


CryptFall's on itch.io if anyone wants to see it in motion: [https://mobtv.itch.io/cryptfall]