spawn beam using range stat and offset position

Author: cdsupina

assets/data/effects.ron

@@ -44,6 +44,15 @@
 			frame_duration: 0.1,
 		),
 	),
+	EnemyBeamSpawn: (
+		effect_type: EnemyBeamSpawn,
+		behaviors: [FadeInAndDespawnAfterAnimation, FollowSource, SpawnProjectileOnDespawn(Beam(Enemy))],
+		z_level: 9.0,
+		animation: (
+			direction: Forward,
+			frame_duration: 0.1,
+		),
+	),
 	AllyBeamDespawn: (
 		effect_type: AllyBeamDespawn,
 		behaviors: [FadeOutAndDespawnAfterAnimation, FollowSource],

assets/data/mobs.ron

@@ -400,6 +400,7 @@
 					spawn_animation_time: 0.5,
 					despawn_animation_time: 0.3,
 					inherit_motion: false,
+					range: 100.0,
 				)
 			]
 		}
@@ -454,6 +455,7 @@
 					spawn_animation_time: 0.3,
 					despawn_animation_time: 0.4,
 					inherit_motion: true,
+					range: 0.0,
 				)
 			],
 			"blast": [
@@ -470,6 +472,7 @@
 					spawn_animation_time: 0.3,
 					despawn_animation_time: 0.4,
 					inherit_motion: true,
+					range: 0.0,
 				)
 			]
 		}
@@ -517,6 +520,7 @@
 					spawn_animation_time: 0.3,
 					despawn_animation_time: 0.4,
 					inherit_motion: true,
+					range: 0.0,
 				)
 			],
 		}
@@ -764,6 +768,7 @@
 					spawn_animation_time: 0.3,
 					despawn_animation_time: 0.4,
 					inherit_motion: true,
+					range: 0.0,
 				)
 			]
 		}
@@ -818,6 +823,7 @@
 					spawn_animation_time: 0.3,
 					despawn_animation_time: 0.4,
 					inherit_motion: true,
+					range: 0.0,
 				)
 			]
 		}

assets/effect_assets.assets.ron

@@ -90,6 +90,13 @@
         columns: 8,
         rows: 1,  
     ),
+    "enemy_beam_spawn": TextureAtlas (
+        path: "texture/enemy_beam_spawn_spritesheet.png",
+        tile_size_x: 9.,
+        tile_size_y: 1.,
+        columns: 8,
+        rows: 1,  
+    ),
     "enemy_beam_despawn": TextureAtlas (
         path: "texture/enemy_beam_despawn_spritesheet.png",
         tile_size_x: 9.,

crates/thetawave_interface/src/spawnable.rs

@@ -196,6 +196,7 @@ pub enum EffectType {
     Text(TextEffectType),
     AllyBeamDespawn,
     EnemyBeamDespawn,
+    EnemyBeamSpawn,
 }
 
 /// Subtype of effect for text effects

src/assets/effect.rs

@@ -19,6 +19,8 @@ pub struct EffectAssets {
     pub enemy_bullet_despawn: Handle<TextureAtlas>,
     #[asset(key = "ally_beam_spawn")]
     pub ally_beam_spawn: Handle<TextureAtlas>,
+    #[asset(key = "enemy_beam_spawn")]
+    pub enemy_beam_spawn: Handle<TextureAtlas>,
     #[asset(key = "ally_beam_despawn")]
     pub ally_beam_despawn: Handle<TextureAtlas>,
     #[asset(key = "ally_bullet_explosion")]
@@ -52,6 +54,7 @@ impl EffectAssets {
             EffectType::Text(_) => None,
             EffectType::AllyBeamDespawn => Some(self.ally_beam_despawn.clone()),
             EffectType::AllyBeamSpawn => Some(self.ally_beam_spawn.clone()),
+            EffectType::EnemyBeamSpawn => Some(self.enemy_beam_spawn.clone()),
             EffectType::EnemyBeamDespawn => Some(self.enemy_beam_despawn.clone()),
         }
     }
@@ -73,6 +76,7 @@ impl EffectAssets {
             EffectType::AllyBeamDespawn => Color::rgb(7.5, 7.5, 7.5),
             EffectType::EnemyBeamDespawn => Color::rgb(7.5, 7.5, 7.5),
             EffectType::AllyBeamSpawn => Color::rgba(2.0, 2.0, 2.0, 0.0),
+            EffectType::EnemyBeamSpawn => Color::rgba(2.0, 2.0, 2.0, 0.0),
         }
     }
 }

src/player/systems/attacks.rs

@@ -4,6 +4,7 @@ use bevy::prelude::*;
 use bevy_rapier2d::prelude::*;
 use leafwing_input_manager::prelude::ActionState;
 use thetawave_interface::input::PlayerAction;
+use thetawave_interface::player;
 use thetawave_interface::spawnable::{EffectType, ProjectileType};
 use thetawave_interface::{
     audio::{PlaySoundEffectEvent, SoundEffectType},
@@ -81,6 +82,7 @@ pub fn player_fire_weapon_system(
                     projectile_spawn: Some(ProjectileSpawnData {
                         damage: player_component.attack_damage,
                         despawn_time: player_component.projectile_despawn_time,
+                        offset_position: player_component.projectile_offset_position,
                     }),
                     ..default()
                 })

src/spawnable/effect/behavior.rs

@@ -1,6 +1,6 @@
 use crate::animation::{AnimationCompleteEvent, AnimationComponent};
 use crate::spawnable::behavior::DespawnSpawnableEvent;
-use crate::spawnable::{SpawnProjectileEvent, TransformType};
+use crate::spawnable::{MobComponent, SpawnProjectileEvent, TransformType};
 use crate::GameUpdateSet;
 use bevy::math::Vec3Swizzles;
 use bevy::prelude::*;
@@ -69,6 +69,7 @@ pub struct FadeInAndDespawnAfterAnimation(pub Stopwatch);
 pub struct FollowSource {
     pub source: Entity,
     pub pos_vec: Vec2,
+    pub offset_pos: Vec2,
 }
 
 #[derive(Component)]
@@ -258,6 +259,7 @@ fn fade_in_despawn_after_animation_effect_behavior_system(
 fn follow_source_system(
     mut projectile_query: Query<(&FollowSource, &mut Transform), With<EffectComponent>>,
     player_query: Query<(&Transform, &PlayerComponent), Without<EffectComponent>>,
+    mob_query: Query<(&Transform, &MobComponent), Without<EffectComponent>>,
 ) {
     for (follow_source, mut effect_transform) in projectile_query.iter_mut() {
         if let Ok((player_transform, player_component)) = player_query.get(follow_source.source) {
@@ -268,6 +270,16 @@ fn follow_source_system(
             // current difference between the effect position and the base spawn position for projectile
             let current_pos_diff = effect_transform.translation.xy() - player_offset_pos;
 
+            // update the effect transform by adding the difference between the follow position and the current difference in position
+            //so that the effect consistently follows the source
+            effect_transform.translation += (follow_source.pos_vec - current_pos_diff).extend(0.0);
+        } else if let Ok((mob_transform, mob_component)) = mob_query.get(follow_source.source) {
+            // get the base spawn point for a effect
+            let mob_offset_pos = mob_transform.translation.xy() + follow_source.offset_pos; // TODO: offset position must be stored with follow source
+
+            // current difference between the effect position and the base spawn position for projectile
+            let current_pos_diff = effect_transform.translation.xy() - mob_offset_pos;
+
             // update the effect transform by adding the difference between the follow position and the current difference in position
             //so that the effect consistently follows the source
             effect_transform.translation += (follow_source.pos_vec - current_pos_diff).extend(0.0);

src/spawnable/effect/spawn.rs

@@ -142,6 +142,12 @@ fn spawn_text_effect(
         },
     };
 
+    let offset_pos = if let Some(ref projectile_spawn) = projectile_spawn {
+        projectile_spawn.offset_position
+    } else {
+        Vec2::ZERO
+    };
+
     // spawn the effect
     let mut effect = commands.spawn_empty();
 
@@ -173,6 +179,7 @@ fn spawn_text_effect(
                         source,
                         pos_vec: text_transform.translation.xy()
                             - original_transform.translation.xy(),
+                        offset_pos,
                     });
                 } else {
                     error!("Source must be Some in order to create FollowSource behavior.")
@@ -229,8 +236,17 @@ fn spawn_effect(
     };
     effect_transform.translation.z = effect_data.z_level;
 
+    let offset_pos = if let Some(ref projectile_spawn) = projectile_spawn {
+        projectile_spawn.offset_position
+    } else {
+        Vec2::ZERO
+    };
+
     // TODO: Replace remove hard coded values and use a player stat instead
-    if matches!(effect_type, EffectType::AllyBeamSpawn) {
+    if matches!(
+        effect_type,
+        EffectType::AllyBeamSpawn | EffectType::EnemyBeamSpawn
+    ) {
         //effect_transform.scale.y *= 50.0;
         effect_transform.translation.y += effect_transform.scale.y / 2.0;
     }
@@ -284,6 +300,7 @@ fn spawn_effect(
                                 effect_transform.translation.x,
                                 effect_transform.translation.y - (effect_transform.scale.y / 2.0),
                             ),
+                        offset_pos,
                     });
                 } else {
                     error!("Source must be Some in order to create FollowSource behavior.")
@@ -313,4 +330,5 @@ fn spawn_effect(
 pub struct ProjectileSpawnData {
     pub damage: usize,
     pub despawn_time: f32,
+    pub offset_position: Vec2,
 }

src/spawnable/mob/behavior.rs

@@ -15,7 +15,8 @@ use crate::{
     collision::SortedCollisionEvent,
     loot::LootDropsResource,
     spawnable::{
-        InitialMotion, SpawnConsumableEvent, SpawnEffectEvent, SpawnProjectileEvent, TransformType,
+        InitialMotion, ProjectileSpawnData, SpawnConsumableEvent, SpawnEffectEvent,
+        SpawnProjectileEvent, TransformType,
     },
 };
 
@@ -147,23 +148,53 @@ pub fn mob_execute_behavior_system(
                                 sound_effect_type: SoundEffectType::EnemyFireBlast,
                             });
 
-                            spawn_projectile_event_writer.send(SpawnProjectileEvent {
-                                projectile_type: projectile_spawner.projectile_type.clone(),
-                                transform_type: TransformType::Initialized(projectile_transform),
-                                damage: projectile_spawner.damage,
-                                despawn_time: projectile_spawner.despawn_time,
-                                initial_motion,
-                                source: entity,
-                                offset_position: match projectile_spawner.position {
-                                    SpawnPosition::Global(coords) => {
-                                        coords - mob_transform.translation.xy()
-                                    }
-                                    SpawnPosition::Local(coords) => {
-                                        mob_transform.local_x().xy() * coords.x
-                                            + mob_transform.local_y().xy() * coords.y
-                                    }
-                                },
-                            });
+                            if let ProjectileType::Beam(_) = projectile_spawner.projectile_type {
+                                spawn_effect_event_writer.send(SpawnEffectEvent {
+                                    effect_type: EffectType::EnemyBeamSpawn,
+                                    transform_type: TransformType::Initialized(
+                                        projectile_transform.with_scale(Vec3::new(
+                                            projectile_transform.scale.x,
+                                            projectile_transform.scale.y * projectile_spawner.range,
+                                            projectile_transform.scale.z,
+                                        )),
+                                    ),
+                                    source: Some(entity),
+                                    projectile_spawn: Some(ProjectileSpawnData {
+                                        damage: projectile_spawner.damage,
+                                        despawn_time: projectile_spawner.despawn_time,
+                                        offset_position: match projectile_spawner.position {
+                                            SpawnPosition::Global(coords) => {
+                                                coords - mob_transform.translation.xy()
+                                            }
+                                            SpawnPosition::Local(coords) => {
+                                                mob_transform.local_x().xy() * coords.x
+                                                    + mob_transform.local_y().xy() * coords.y
+                                            }
+                                        },
+                                    }),
+                                    ..default()
+                                });
+                            } else {
+                                spawn_projectile_event_writer.send(SpawnProjectileEvent {
+                                    projectile_type: projectile_spawner.projectile_type.clone(),
+                                    transform_type: TransformType::Initialized(
+                                        projectile_transform,
+                                    ),
+                                    damage: projectile_spawner.damage,
+                                    despawn_time: projectile_spawner.despawn_time,
+                                    initial_motion,
+                                    source: entity,
+                                    offset_position: match projectile_spawner.position {
+                                        SpawnPosition::Global(coords) => {
+                                            coords - mob_transform.translation.xy()
+                                        }
+                                        SpawnPosition::Local(coords) => {
+                                            mob_transform.local_x().xy() * coords.x
+                                                + mob_transform.local_y().xy() * coords.y
+                                        }
+                                    },
+                                });
+                            }
                         }
                     }
                 }

src/spawnable/mob/mod.rs

@@ -140,6 +140,7 @@ pub struct ProjectileSpawner {
     pub spawn_animation_time: f32,
     pub despawn_animation_time: f32,
     pub inherit_motion: bool,
+    pub range: f32,
 }
 
 impl From<ProjectileSpawnerData> for ProjectileSpawner {
@@ -154,6 +155,7 @@ impl From<ProjectileSpawnerData> for ProjectileSpawner {
             spawn_animation_time: value.spawn_animation_time,
             despawn_animation_time: value.despawn_animation_time,
             inherit_motion: value.inherit_motion,
+            range: value.range,
         }
     }
 }
@@ -168,8 +170,10 @@ pub struct ProjectileSpawnerData {
     pub damage: usize,
     pub spawn_animation_time: f32,
     pub despawn_animation_time: f32,
-    /// Whether to add motion the from entity spawning projectile to the projectile
+    /// whether to add motion the from entity spawning projectile to the projectile
     pub inherit_motion: bool,
+    /// used for certain projectiles (like the beam) to determine the length
+    pub range: f32,
 }
 
 #[derive(Deserialize, Clone)]