Merge #272

272: Boss Bomb Throwing r=odecay a=Zac8668

Implements boss bomb throwing
Closes #269 

Co-authored-by: Isaac <78173025+Zac8668@users.noreply.github.com>
Co-authored-by: odecay <electricbuck@gmail.com>

Author: 3 people

assets/fighters/big_bass/big_bass.fighter.yaml

@@ -40,6 +40,8 @@ spritesheet:
       repeat: false
     attacking:
       frames: [30, 44]
+    bomb_throw:
+      frames: [45, 51]
 
 attacks:
   - name: "ground_slam"
@@ -52,6 +54,17 @@ attacks:
       size: [96, 32]
       offset: [0, -69]
     hitstun_duration: 0.2
+  - name: "bomb_throw"
+    damage: 100
+    frames:
+      startup: 5
+      active: 6
+      recovery: 6
+    hitbox:
+      size: [96, 32]
+      offset: [0, 0]
+    hitstun_duration: 0.2
+    item: /items/bomb/bomb.item.yaml
 
 audio:
   effects:

assets/items/bomb/bomb.item.yaml

@@ -0,0 +1,25 @@
+name: Bomb
+
+image:
+  image: bomb_icon.png
+  image_size: [32, 32]
+
+kind: !Bomb
+  spritesheet:
+    image: [bomb_144_112.png]
+    tile_size: [144, 112]
+    columns: 11
+    rows: 3
+
+    animation_fps: 0.12
+    animations:
+      explosion:
+        frames: [0, 10]
+      bomb:
+        frames: [11, 11]
+      bomb_fuse:
+        frames: [22, 24]
+  attack_frames:
+    startup: 0
+    active: 3
+    recovery: 3

assets/items/bomb/bomb_144_112.png

@@ -267,6 +267,17 @@ impl AssetLoader for FighterLoader {
             let self_path = load_context.path();
             let mut dependencies = Vec::new();
 
+            for attack in &mut meta.attacks {
+                if let Some(item) = &attack.item {
+                    let (item_path, item_handle) =
+                        get_relative_asset(load_context, self_path, item);
+
+                    dependencies.push(item_path);
+
+                    attack.item_handle = item_handle;
+                }
+            }
+
             let (portrait_path, portrait_handle) =
                 get_relative_asset(load_context, self_path, &meta.hud.portrait.image);
             dependencies.push(portrait_path);
@@ -424,6 +435,24 @@ impl AssetLoader for ItemLoader {
                     dependencies.push(script_path);
                     *script_handle = loaded_script_handle;
                 }
+                ItemKind::Bomb { spritesheet, .. } => {
+                    for (index, image) in spritesheet.image.iter().enumerate() {
+                        let (texture_path, texture_handle) =
+                            get_relative_asset(load_context, load_context.path(), image);
+
+                        let atlas_handle = load_context.set_labeled_asset(
+                            format!("atlas_{}", index).as_str(),
+                            LoadedAsset::new(TextureAtlas::from_grid(
+                                texture_handle,
+                                spritesheet.tile_size.as_vec2(),
+                                spritesheet.columns,
+                                spritesheet.rows,
+                            ))
+                            .with_dependency(texture_path),
+                        );
+                        spritesheet.atlas_handle.push(atlas_handle);
+                    }
+                }
                 _ => {}
             }
 

assets/items/bomb/bomb_icon.png

@@ -14,7 +14,7 @@ use crate::{
     damage::{DamageEvent, Damageable, Health},
     enemy::Enemy,
     fighter_state::MeleeWeapon,
-    item::Drop,
+    item::{Drop, Explodable},
     metadata::ColliderMeta,
     player::Player,
     GameState,
@@ -83,6 +83,7 @@ impl Breakable {
 pub struct BrokeEvent {
     pub drop: Option<Drop>,
     pub transform: Option<Transform>,
+    pub explodable: Option<Explodable>,
 }
 
 /// A component identifying the attacks active collision frames.
@@ -102,7 +103,15 @@ pub struct AttackFrames {
 //TODO: is there a way we can move the adding of collision layers here as well?
 fn activate_hitbox(
     attack_query: Query<(Entity, &Attack, &AttackFrames, &Parent), Without<Collider>>,
-    parent_query: Query<&Animation, Or<(With<Player>, With<Enemy>, With<MeleeWeapon>)>>,
+    parent_query: Query<
+        &Animation,
+        Or<(
+            With<Player>,
+            With<Enemy>,
+            With<MeleeWeapon>,
+            With<Explodable>,
+        )>,
+    >,
     mut commands: Commands,
 ) {
     for (entity, attack, attack_frames, parent) in attack_query.iter() {
@@ -191,20 +200,24 @@ fn breakable_system(
         Option<&Drop>,
         Option<&Transform>,
         Option<&Parent>,
+        Option<&Explodable>,
     )>,
     mut commands: Commands,
     mut event_writer: EventWriter<BrokeEvent>,
 ) {
     for ev in events.iter() {
         if let CollisionEvent::Started(e1, e2, _flags) = ev {
             for e in [e1, e2].iter() {
-                if let Ok((mut breakable, drop, transform, parent)) = despawn_query.get_mut(**e) {
+                if let Ok((mut breakable, drop, transform, parent, explodable)) =
+                    despawn_query.get_mut(**e)
+                {
                     if breakable.hit_count < breakable.hit_tolerance {
                         breakable.hit_count += 1;
                     } else {
                         event_writer.send(BrokeEvent {
                             drop: drop.cloned(),
                             transform: transform.cloned(),
+                            explodable: explodable.cloned(),
                         });
                         commands.entity(**e).despawn_recursive();
 

src/assets.rs

@@ -8,7 +8,7 @@ use crate::{
     consts::{self, ENEMY_MAX_ATTACK_DISTANCE, ENEMY_MIN_ATTACK_DISTANCE, ENEMY_TARGET_MAX_OFFSET},
     enemy::{Boss, Enemy, TripPointX},
     fighter_state::{
-        GroundSlam, Idling, Moving, Punching, StateTransition, StateTransitionIntents,
+        BossBombThrow, Idling, Moving, Punching, StateTransition, StateTransitionIntents,
     },
     player::Player,
     Stats,
@@ -142,9 +142,10 @@ pub fn emit_enemy_intents(
             // make them attack with their first available attack??
             // And attack!
             if maybe_boss.is_some() {
+                // TODO Add some proper ai for the bomb throw
                 intents.push_back(StateTransition::new(
-                    GroundSlam::default(),
-                    GroundSlam::PRIORITY,
+                    BossBombThrow::default(),
+                    BossBombThrow::PRIORITY,
                     false,
                 ))
             } else {

src/attack.rs

@@ -17,7 +17,10 @@ use crate::{
     enemy_ai,
     fighter::{Attached, AvailableAttacks, Inventory},
     input::PlayerAction,
-    item::{Drop, Item, ItemBundle, Projectile, ScriptItemGrabEvent, ScriptItemThrowEvent},
+    item::{
+        AnimatedProjectile, Drop, Explodable, Item, ItemBundle, Projectile, ScriptItemGrabEvent,
+        ScriptItemThrowEvent,
+    },
     lifetime::Lifetime,
     metadata::{AttackMeta, AudioMeta, FighterMeta, ItemKind, ItemMeta, ItemSpawnMeta},
     movement::LinearVelocity,
@@ -63,6 +66,7 @@ impl Plugin for FighterStatePlugin {
                     .with_system(transition_from_hitstun)
                     .with_system(transition_from_melee_attacking)
                     .with_system(transition_from_shooting)
+                    .with_system(transition_from_bomb_throw)
                     .into(),
             )
             // State handler systems
@@ -82,6 +86,7 @@ impl Plugin for FighterStatePlugin {
                     .with_system(holding)
                     .with_system(melee_attacking)
                     .with_system(shooting)
+                    .with_system(bomb_throw)
                     .into(),
             );
     }
@@ -248,6 +253,18 @@ impl GroundSlam {
     pub const ANIMATION: &'static str = "attacking";
 }
 
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct BossBombThrow {
+    pub has_started: bool,
+    pub is_finished: bool,
+    pub thrown: bool,
+}
+impl BossBombThrow {
+    pub const PRIORITY: i32 = 30;
+    pub const ANIMATION: &'static str = "bomb_throw";
+}
+
 #[derive(Component, Reflect, Default, Debug)]
 #[component(storage = "SparseSet")]
 pub struct Punching {
@@ -542,6 +559,35 @@ fn transition_from_ground_slam(
     }
 }
 
+fn transition_from_bomb_throw(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &mut StateTransitionIntents, &BossBombThrow)>,
+) {
+    'entity: for (entity, mut transition_intents, bomb_throw) in &mut fighters {
+        // Transition to any higher priority states
+        let current_state_removed = transition_intents
+            .transition_to_higher_priority_states::<BossBombThrow>(
+                entity,
+                BossBombThrow::PRIORITY,
+                &mut commands,
+            );
+
+        // If our current state was removed, don't continue processing this fighter
+        if current_state_removed {
+            continue 'entity;
+        }
+
+        // If we're done flopping
+        if bomb_throw.is_finished {
+            // Go back to idle
+            commands
+                .entity(entity)
+                .remove::<BossBombThrow>()
+                .insert(Idling);
+        }
+    }
+}
+
 // Initiate any transitions from the hit stun state
 fn transition_from_hitstun(
     mut commands: Commands,
@@ -999,6 +1045,112 @@ fn ground_slam(
     }
 }
 
+fn bomb_throw(
+    mut commands: Commands,
+    mut fighters: Query<
+        (
+            &mut Animation,
+            &mut LinearVelocity,
+            &Facing,
+            &Transform,
+            &Handle<FighterMeta>,
+            &mut BossBombThrow,
+            &AvailableAttacks,
+        ),
+        With<Boss>,
+    >,
+    fighter_assets: Res<Assets<FighterMeta>>,
+    item_assets: Res<Assets<ItemMeta>>,
+) {
+    for (
+        mut animation,
+        mut velocity,
+        facing,
+        transform,
+        meta_handle,
+        mut bomb_throw,
+        available_attacks,
+    ) in &mut fighters
+    {
+        // Start the attack
+        if let Some(fighter) = fighter_assets.get(meta_handle) {
+            let attack = available_attacks.current_attack();
+            let item = item_assets
+                .get(&attack.item_handle)
+                .expect("Fighter has no item");
+
+            let (mut sprite, mut frames) = (None, None);
+            if let ItemKind::Bomb {
+                attack_frames,
+                spritesheet,
+            } = &item.kind
+            {
+                sprite = Some(spritesheet);
+                frames = Some(attack_frames);
+            }
+            let (spritesheet, attack_frames) = (
+                sprite.expect("No bomb item found."),
+                frames.expect("No bomb item found;."),
+            );
+
+            let mut translation = transform.translation;
+            translation.z += 0.2; // Get above boss
+            translation.x +=
+                (spritesheet.tile_size.x / 3) as f32 * if facing.is_left() { -1. } else { 1. };
+            translation.y += (spritesheet.tile_size.y / 2) as f32;
+            let mut animated_sprite = AnimatedSpriteSheetBundle {
+                sprite_sheet: SpriteSheetBundle {
+                    texture_atlas: spritesheet.atlas_handle[0].clone(),
+                    transform: Transform::from_translation(translation),
+                    ..Default::default()
+                },
+                animation: Animation::new(
+                    spritesheet.animation_fps,
+                    spritesheet.animations.clone(),
+                ),
+            };
+            animated_sprite.animation.current_animation = Some("bomb".to_string());
+
+            let mut offset = attack.hitbox.offset;
+            if facing.is_left() {
+                offset.x *= -1.0
+            }
+            offset.y += fighter.collision_offset;
+
+            if !bomb_throw.has_started {
+                bomb_throw.has_started = true;
+
+                // Start the attack  from the beginning
+                animation.play(BossBombThrow::ANIMATION, false);
+            }
+
+            if !animation.is_finished() {
+                // Frames that each bomb is thrown
+                if (animation.current_frame == attack.frames.startup && !bomb_throw.thrown)
+                    || (animation.current_frame == attack.frames.active && bomb_throw.thrown)
+                {
+                    // Spawn bomb
+                    commands
+                        .spawn_bundle(AnimatedProjectile::new(0, facing, animated_sprite.clone()))
+                        .insert(Explodable {
+                            attack: attack.clone(),
+                            timer: Timer::from_seconds(consts::THROW_ITEM_LIFETIME, false),
+                            fusing: false,
+                            animated_sprite,
+                            explosion_frames: *attack_frames,
+                        });
+                    bomb_throw.thrown = !bomb_throw.thrown;
+                }
+            } else if animation.is_finished() {
+                bomb_throw.is_finished = true;
+            }
+
+            // Stop boss
+            **velocity = Vec2::ZERO;
+        }
+    }
+}
+
 /// Handle fighter moving state
 fn moving(
     mut commands: Commands,
@@ -1206,6 +1358,9 @@ fn throwing(
                         }
                     }
                 }
+                ItemKind::Bomb { .. } => {
+                    panic!("Can't throw bomb")
+                }
             }
         }
 
@@ -1403,6 +1558,9 @@ fn grabbing(
                                     .id();
                                 commands.entity(fighter_ent).add_child(weapon);
                             }
+                            ItemKind::Bomb { .. } => {
+                                panic!("Can't pick up bomb")
+                            }
                         }
                     }
                     break;