feat: Add earth prison spell to demon boss

src/assets.rs

@@ -183,6 +183,8 @@ pub struct GameAssets {
     pub demon_boss_step_sound: Handle<AudioSource>,
     #[asset(path = "sounds/demon_boss_vocal_explosion.ogg")]
     pub demon_boss_vocal_explosion_sound: Handle<AudioSource>,
+    #[asset(path = "sounds/demon_boss_vocal_earth_prison.ogg")]
+    pub demon_boss_vocal_earth_prison_sound: Handle<AudioSource>,
     #[asset(path = "sounds/gitgud.ogg")]
     pub git_gud: Handle<AudioSource>,
 

src/enemy/demon_boss/audio.rs

@@ -67,6 +67,7 @@ fn play_cast_vocals(
     for demon_spell in &q_demon_spells {
         let vocals = match demon_spell.spell {
             DemonSpell::Explosion => assets.demon_boss_vocal_explosion_sound.clone(),
+            DemonSpell::EarthPrison => assets.demon_boss_vocal_earth_prison_sound.clone(),
         };
 
         play_sound.send(PlaySound {

src/enemy/demon_boss/cast.rs

@@ -1,11 +1,14 @@
+use rand::{thread_rng, Rng};
+
 use bevy::prelude::*;
 
 use super::{state::DemonBossState, DemonBoss};
 use crate::GameState;
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Copy)]
 pub enum DemonSpell {
     Explosion,
+    EarthPrison,
 }
 
 #[derive(Component, Clone)]
@@ -14,16 +17,28 @@ pub struct DemonSpellCast {
     pub timer: Timer,
 }
 
-#[derive(Event, Deref, DerefMut)]
-pub struct SpawnDemonSpell(pub DemonSpellCast);
-
 #[derive(Component)]
 pub struct DemonSpellCooldown {
     #[allow(dead_code)]
     spell: DemonSpell,
     timer: Timer,
 }
 
+#[derive(Component, Deref, DerefMut)]
+pub struct LastSpellTimer(Timer);
+
+#[derive(Event, Deref, DerefMut)]
+pub struct SpawnDemonSpell(pub DemonSpellCast);
+
+fn pick_random_spell() -> DemonSpell {
+    let mut rng = thread_rng();
+
+    match rng.gen_range(0..2) {
+        0 => DemonSpell::Explosion,
+        _ => DemonSpell::EarthPrison,
+    }
+}
+
 fn spawn_demon_spell(
     mut commands: Commands,
     q_demon_boss: Query<&DemonBoss>,
@@ -45,12 +60,14 @@ fn spawn_demon_spell(
         return;
     }
 
+    let spell = pick_random_spell();
+
     commands.spawn(DemonSpellCooldown {
-        spell: DemonSpell::Explosion,
+        spell,
         timer: Timer::from_seconds(5.0, TimerMode::Once),
     });
     commands.spawn(DemonSpellCast {
-        spell: DemonSpell::Explosion,
+        spell,
         timer: Timer::from_seconds(1.5, TimerMode::Once),
     });
 }
@@ -83,6 +100,29 @@ fn despawn_spell_cooldowns(
     }
 }
 
+fn spawn_last_spell_timer(mut commands: Commands) {
+    commands.spawn(LastSpellTimer(Timer::from_seconds(10.0, TimerMode::Once)));
+}
+
+fn reset_last_spell_timer(
+    time: Res<Time>,
+    mut q_last_spell_timer: Query<&mut LastSpellTimer>,
+    mut ev_spawn_demon_spell: EventReader<SpawnDemonSpell>,
+) {
+    let mut timer = match q_last_spell_timer.get_single_mut() {
+        Ok(r) => r,
+        Err(_) => return,
+    };
+    timer.tick(time.delta());
+
+    if ev_spawn_demon_spell.is_empty() {
+        return;
+    }
+    ev_spawn_demon_spell.clear();
+
+    timer.reset();
+}
+
 pub struct DemonBossCastPlugin;
 
 impl Plugin for DemonBossCastPlugin {
@@ -93,9 +133,11 @@ impl Plugin for DemonBossCastPlugin {
                 spawn_demon_spell,
                 despawn_spell_cooldowns,
                 relay_demon_spells,
+                reset_last_spell_timer,
             )
                 .run_if(in_state(GameState::Gaming)),
         )
-        .add_event::<SpawnDemonSpell>();
+        .add_event::<SpawnDemonSpell>()
+        .add_systems(OnEnter(GameState::Gaming), spawn_last_spell_timer);
     }
 }

src/enemy/demon_boss/earth_prison.rs

@@ -0,0 +1,163 @@
+use std::f32::consts::{PI, TAU};
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+use bevy_trickfilm::prelude::*;
+
+use crate::{audio::PlaySound, player::Player, world::camera::YSort, GameAssets, GameState};
+
+use super::{
+    cast::{DemonSpell, SpawnDemonSpell},
+    DemonBoss,
+};
+
+const WALL_PADDING: f32 = 10.0;
+const COUNT: usize = 25;
+const RADIUS: f32 = 100.0;
+const OFFSET: f32 = 50.0;
+
+#[derive(Component, Default)]
+struct DemonBossEarthWall {
+    despawning: bool,
+}
+#[derive(Component)]
+struct DemonBossEarthWallCollider {
+    timer: Timer,
+}
+
+fn spawn_wall(commands: &mut Commands, assets: &Res<GameAssets>, pos: Vec3, flip_x: bool) {
+    let mut animator = AnimationPlayer2D::default();
+    animator.play(assets.earth_wall_animations[0].clone());
+
+    commands.spawn((
+        DemonBossEarthWall::default(),
+        animator,
+        YSort(0.0),
+        SpriteSheetBundle {
+            transform: Transform::from_translation(pos),
+            texture_atlas: assets.earth_wall.clone(),
+            sprite: TextureAtlasSprite {
+                flip_x,
+                ..default()
+            },
+            ..default()
+        },
+    ));
+}
+
+fn spawn_collider(commands: &mut Commands, pos: Vec3, offset: f32, angle: f32) {
+    let mut vertices = Vec::new();
+    for i in 0..COUNT {
+        let rot = Quat::from_rotation_z(angle + 3.0 / 2.0 * PI * i as f32 / COUNT as f32);
+        let pos = rot.mul_vec3(Vec3::X * offset - WALL_PADDING);
+        vertices.push(Vect::new(pos.x, pos.y));
+    }
+
+    commands.spawn((
+        DemonBossEarthWallCollider {
+            timer: Timer::from_seconds(7.0, TimerMode::Once),
+        },
+        Collider::polyline(vertices, None),
+        CollisionGroups::default(),
+        TransformBundle::from_transform(Transform::from_translation(pos)),
+    ));
+}
+
+fn spawn_earth_prison(
+    mut commands: Commands,
+    assets: Res<GameAssets>,
+    q_player: Query<&Transform, With<Player>>,
+    q_demon_boss: Query<&Transform, (With<DemonBoss>, Without<Player>)>,
+    mut ev_spawn_demon_spells: EventReader<SpawnDemonSpell>,
+    mut ev_play_sound: EventWriter<PlaySound>,
+) {
+    let player_pos = match q_player.get_single() {
+        Ok(r) => r.translation,
+        Err(_) => return,
+    };
+    let demon_boss_pos = match q_demon_boss.get_single() {
+        Ok(r) => r.translation,
+        Err(_) => return,
+    };
+
+    let dis = demon_boss_pos - player_pos;
+    let pos = player_pos + dis.normalize_or_zero() * OFFSET;
+    let angle = dis.angle_between(Vec3::X) + PI / 4.0;
+
+    for ev in ev_spawn_demon_spells.read() {
+        if ev.spell != DemonSpell::EarthPrison {
+            continue;
+        }
+
+        ev_play_sound.send(PlaySound {
+            clip: assets.earth_wall_sound.clone(),
+            ..default()
+        });
+
+        spawn_collider(&mut commands, pos, RADIUS, angle);
+        for i in 0..COUNT {
+            let rot = Quat::from_rotation_z(angle + 3.0 / 2.0 * PI * i as f32 / COUNT as f32);
+            let pos = pos + rot.mul_vec3(Vec3::X * RADIUS);
+            let flip_x = rot.to_euler(EulerRot::ZYX).0.abs() < TAU / 4.0;
+            spawn_wall(&mut commands, &assets, pos, flip_x);
+        }
+    }
+}
+
+fn despawn_earth_prison(
+    mut commands: Commands,
+    assets: Res<GameAssets>,
+    time: Res<Time>,
+    mut q_earth_walls: Query<(&mut DemonBossEarthWall, &mut AnimationPlayer2D)>,
+    mut q_earth_wall_colliders: Query<(Entity, &mut DemonBossEarthWallCollider)>,
+) {
+    let mut despawn = false;
+    for (_, mut collider) in &mut q_earth_wall_colliders {
+        collider.timer.tick(time.delta());
+        if collider.timer.just_finished() {
+            despawn = true;
+        }
+    }
+
+    if !despawn {
+        return;
+    }
+
+    for (entity, _) in &q_earth_wall_colliders {
+        commands.entity(entity).despawn_recursive();
+    }
+
+    for (mut earth_wall, mut animator) in &mut q_earth_walls {
+        if !earth_wall.despawning {
+            earth_wall.despawning = true;
+            animator.play(assets.earth_wall_animations[1].clone());
+        }
+    }
+}
+
+fn despawn_walls(
+    mut commands: Commands,
+    q_earth_walls: Query<(Entity, &DemonBossEarthWall, &AnimationPlayer2D)>,
+) {
+    for (entity, earth_wall, animator) in &q_earth_walls {
+        if !earth_wall.despawning {
+            continue;
+        }
+
+        if animator.is_finished() {
+            commands.entity(entity).despawn_recursive();
+        }
+    }
+}
+
+pub struct DemonBossEarthPrisonPlugin;
+
+impl Plugin for DemonBossEarthPrisonPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            Update,
+            (spawn_earth_prison, despawn_earth_prison, despawn_walls)
+                .run_if(in_state(GameState::Gaming)),
+        );
+    }
+}

src/enemy/demon_boss/mod.rs

@@ -3,6 +3,7 @@ pub mod explosion;
 mod audio;
 mod cast;
 mod collision;
+mod earth_prison;
 mod movement;
 mod rage;
 mod spawn;
@@ -27,6 +28,7 @@ impl Plugin for DemonBossPlugin {
             explosion::DemonBossExplosionPlugin,
             collision::DemonBossCollisionPlugin,
             rage::DemonBossRagePlugin,
+            earth_prison::DemonBossEarthPrisonPlugin,
         ));
     }
 }

src/enemy/demon_boss/state.rs

@@ -4,7 +4,7 @@ use bevy_trickfilm::prelude::*;
 use crate::{player::Player, GameAssets, GameState};
 
 use super::{
-    cast::{DemonSpellCooldown, SpawnDemonSpell},
+    cast::{DemonSpellCooldown, LastSpellTimer, SpawnDemonSpell},
     movement::MovementCooldownTimer,
     strike::StrikeCooldown,
     DemonBoss, INV_CAST_RANGE, STRIKE_RANGE,
@@ -163,6 +163,7 @@ fn switch_to_casting(
     mut q_demon_boss: Query<(&Transform, &mut DemonBoss)>,
     q_player: Query<&Transform, (With<Player>, Without<DemonBoss>)>,
     q_demon_spell_cooldown: Query<&DemonSpellCooldown>,
+    q_last_spell_timer: Query<&LastSpellTimer>,
 ) {
     if !q_demon_spell_cooldown.is_empty() {
         return;
@@ -175,6 +176,10 @@ fn switch_to_casting(
         Ok(p) => p.translation,
         Err(_) => return,
     };
+    let last_spell_timer = match q_last_spell_timer.get_single() {
+        Ok(r) => r,
+        Err(_) => return,
+    };
 
     if demon_boss.state == DemonBossState::Casting {
         return;
@@ -188,7 +193,7 @@ fn switch_to_casting(
         .distance_squared(demon_boss_transform.translation.truncate());
     let inv_cast_range = INV_CAST_RANGE.powi(2);
 
-    if dis >= inv_cast_range {
+    if dis >= inv_cast_range || last_spell_timer.finished() {
         demon_boss.state = DemonBossState::Casting;
     }
 }