Refactored projectiles

Author: Aunmag

src/command/mod.rs

@@ -2,8 +2,5 @@ mod actor_player_set;
 mod actor_release;
 mod actor_set;
 mod cursor_grab;
-mod projectile_spawn;
 
-pub use self::{
-    actor_player_set::*, actor_release::*, actor_set::*, cursor_grab::*, projectile_spawn::*,
-};
+pub use self::{actor_player_set::*, actor_release::*, actor_set::*, cursor_grab::*};

src/component/mod.rs

@@ -2,6 +2,5 @@ mod actor;
 mod collision;
 mod inertia;
 mod player;
-mod projectile;
 
-pub use self::{actor::*, collision::*, inertia::*, player::*, projectile::*};
+pub use self::{actor::*, collision::*, inertia::*, player::*};

src/component/projectile.rs

@@ -10,7 +10,6 @@ mod system;
 mod util;
 
 use crate::{
-    component::ProjectileMaterial,
     data::APP_TITLE,
     event::ActorDeathEvent,
     model::AppState,
@@ -29,10 +28,9 @@ use bevy::{
     log::LogPlugin,
     prelude::{App, DefaultPlugins, IntoSystem, IntoSystemConfigs, PluginGroup},
     render::texture::ImagePlugin,
-    sprite::Material2dPlugin,
     window::{Window, WindowPlugin, WindowResolution},
 };
-use plugin::WeaponPlugin;
+use plugin::{ProjectilePlugin, WeaponPlugin};
 
 fn main() {
     // TODO: init logger earlier
@@ -93,12 +91,12 @@ fn main() {
         .add_plugins(HeartbeatPlugin)
         .add_plugins(LaserSightPlugin)
         .add_plugins(ParticlePlugin)
+        .add_plugins(ProjectilePlugin)
         .add_plugins(StatusBarPlugin)
         .add_plugins(TerrainPlugin)
         .add_plugins(TileMapPlugin)
         .add_plugins(UiNotificationPlugin)
         .add_plugins(WeaponPlugin)
-        .add_plugins(Material2dPlugin::<ProjectileMaterial>::default())
         .add_state::<AppState>()
         .add_event::<ActorDeathEvent>()
         .insert_resource(AssetStorage::default())
@@ -119,8 +117,6 @@ fn main() {
             s.add(inertia.after(actor));
             s.add(collision_find.pipe(collision_resolve).after(inertia));
             s.add(melee.after(collision_resolve));
-            s.add(projectile.after(collision_resolve));
-            s.add(projectile_whiz);
             s.add(ambience_fx());
             s.add(scenario);
         })

src/main.rs

@@ -11,6 +11,7 @@ mod health;
 mod heartbeat;
 mod laser;
 mod particle;
+mod projectile;
 mod status_bar;
 mod terrain;
 mod tile_map;
@@ -19,6 +20,6 @@ mod weapon;
 
 pub use self::{
     audio::*, blood::*, bonus::*, breath::*, camera_target::*, crosshair::*, debug::*,
-    footsteps::*, health::*, heartbeat::*, laser::*, particle::*, status_bar::*, terrain::*,
-    tile_map::*, ui_notification::*, weapon::*,
+    footsteps::*, health::*, heartbeat::*, laser::*, particle::*, projectile::*, status_bar::*,
+    terrain::*, tile_map::*, ui_notification::*, weapon::*,
 };

src/plugin/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
-    component::{Projectile, ProjectileConfig, ProjectileMaterial},
     data::LAYER_PROJECTILE,
     model::TransformLite,
+    plugin::{projectile::material::ProjectileMaterial, Projectile, ProjectileConfig},
     resource::AssetStorage,
     util::ext::Vec2Ext,
 };

src/command/projectile_spawn.rs src/plugin/projectile/command.rssrc/command/projectile_spawn.rs renamed to src/plugin/projectile/command.rs

@@ -0,0 +1,47 @@
+use crate::plugin::ProjectileConfig;
+use bevy::{
+    ecs::{component::Component, entity::Entity},
+    math::Vec2,
+};
+use std::time::Duration;
+
+#[derive(Component)]
+pub struct Projectile {
+    pub config: &'static ProjectileConfig,
+    pub initial_time: Duration,
+    pub initial_position: Vec2,
+    pub initial_velocity: Vec2,
+    pub shooter: Option<Entity>,
+    pub stopped: bool,
+}
+
+impl Projectile {
+    pub const VELOCITY_MIN: f32 = 5.0;
+    pub const VELOCITY_VISUAL_FACTOR: f32 = 1.0 / 5.0;
+
+    pub const fn new(
+        config: &'static ProjectileConfig,
+        time: Duration,
+        position: Vec2,
+        velocity: Vec2,
+        shooter: Option<Entity>,
+    ) -> Self {
+        return Self {
+            config,
+            initial_time: time,
+            initial_position: position,
+            initial_velocity: velocity,
+            shooter,
+            stopped: false,
+        };
+    }
+
+    pub fn calc_data(&self, time: Duration) -> (Vec2, Vec2) {
+        let t = time.saturating_sub(self.initial_time).as_secs_f32();
+        let a = self.config.acceleration();
+        let p = self.initial_position;
+        let v0 = self.initial_velocity;
+        let v1 = v0 * (t * a).exp();
+        return (p + (v1 - v0) / a * Projectile::VELOCITY_VISUAL_FACTOR, v1);
+    }
+}

src/plugin/projectile/component.rs

@@ -0,0 +1,46 @@
+#[derive(Clone)]
+pub struct ProjectileConfig {
+    pub fragments: u8,
+    pub mass: f32,
+    pub size: f32,
+}
+
+impl ProjectileConfig {
+    pub const _9X18: Self = Self {
+        fragments: 1,
+        mass: 0.0061,
+        size: 0.7,
+    };
+
+    pub const _7_62X25: Self = Self {
+        fragments: 1,
+        mass: 0.0055,
+        size: 0.7,
+    };
+
+    pub const _12X76: Self = Self {
+        fragments: 12,
+        mass: 0.048,
+        size: 0.1,
+    };
+
+    pub const _5_45X39: Self = Self {
+        fragments: 1,
+        mass: 0.0034,
+        size: 1.0,
+    };
+
+    pub const _7_62X54: Self = Self {
+        fragments: 1,
+        mass: 0.0096,
+        size: 1.2,
+    };
+
+    pub fn acceleration(&self) -> f32 {
+        return -1.0 / self.fragment_mass() * 0.006 - 4.2;
+    }
+
+    pub fn fragment_mass(&self) -> f32 {
+        return self.mass / f32::from(self.fragments);
+    }
+}

src/plugin/projectile/config.rs

@@ -0,0 +1,20 @@
+use bevy::{
+    asset::Asset,
+    prelude::{Handle, Image},
+    reflect::TypePath,
+    render::render_resource::{AsBindGroup, ShaderRef},
+    sprite::Material2d,
+};
+
+#[derive(Debug, Clone, Asset, TypePath, AsBindGroup)]
+pub struct ProjectileMaterial {
+    #[texture(0)]
+    #[sampler(1)]
+    pub image: Handle<Image>,
+}
+
+impl Material2d for ProjectileMaterial {
+    fn fragment_shader() -> ShaderRef {
+        return "shader/projectile.wgsl".into();
+    }
+}

src/plugin/projectile/material.rs

@@ -0,0 +1,27 @@
+mod command;
+mod component;
+mod config;
+mod material;
+mod sys_update;
+mod sys_whiz;
+
+use self::material::ProjectileMaterial;
+pub use self::{command::*, component::*, config::*};
+use crate::{model::AppState, system::game::collision_resolve, util::ext::AppExt};
+use bevy::{
+    prelude::{App, IntoSystemConfigs, Plugin},
+    sprite::Material2dPlugin,
+};
+
+pub struct ProjectilePlugin;
+
+impl Plugin for ProjectilePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(Material2dPlugin::<ProjectileMaterial>::default());
+        app.add_state_system(
+            AppState::Game,
+            sys_update::on_update.after(collision_resolve),
+        );
+        app.add_state_system(AppState::Game, sys_whiz::on_update);
+    }
+}