Merge pull request #2 from cBournhonesque/cb/projectiles

Adds basic projectiles

renderer/src/lib.rs

@@ -1,5 +1,5 @@
 mod player;
-mod weapon;
+mod projectiles;
 
 use bevy::prelude::*;
 use lightyear::client::interpolation::VisualInterpolationPlugin;
@@ -12,6 +12,7 @@ impl Plugin for RendererPlugin {
         // TODO: add option to disable inspector
         app.add_plugins(bevy_inspector_egui::quick::WorldInspectorPlugin::new());
         app.add_plugins(player::PlayerPlugin);
+        app.add_plugins(projectiles::ProjectilesPlugin);
         app.insert_resource(AmbientLight {
             brightness: 0.0,
             ..default()

renderer/src/player.rs

@@ -1,7 +1,6 @@
 use bevy::color::palettes::basic::BLUE;
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::prelude::*;
-use bevy::render::camera::Exposure;
 use lightyear::prelude::client::{Confirmed, Predicted, VisualInterpolateStatus};
 use lightyear::shared::replication::components::Controlled;
 use shared::player::Player;

renderer/src/projectiles.rs

@@ -0,0 +1,34 @@
+use bevy::color::palettes::basic::BLUE;
+use bevy::prelude::*;
+use shared::projectiles::Projectile;
+
+pub(crate) struct ProjectilesPlugin;
+
+impl Plugin for ProjectilesPlugin {
+    fn build(&self, app: &mut App) {
+        // SYSTEMS
+        app.add_observer(spawn_visuals);
+    }
+}
+
+/// When a projectile is spawn, add visuals to it
+fn spawn_visuals(
+    trigger: Trigger<OnAdd, Projectile>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.entity(trigger.entity()).with_child(
+        (
+            Mesh3d(meshes.add(Mesh::from(Sphere {
+                // TODO: must match the collider size
+                radius: 0.1,
+                ..default()
+            }))),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: BLUE.into(),
+                ..Default::default()
+            })),
+        )
+    );
+}

shared/src/lib.rs

@@ -6,7 +6,7 @@ mod map;
 mod states;
 mod physics;
 pub mod player;
-mod weapons;
+pub mod projectiles;
 
 pub mod prelude {
     pub use crate::network::{protocol::*, settings::*};
@@ -27,6 +27,6 @@ impl Plugin for SharedPlugin {
         app.add_plugins(map::MapPlugin { headless: self.headless});
         app.add_plugins(physics::PhysicsPlugin);
         app.add_plugins(player::PlayerPlugin);
-        app.add_plugins(weapons::WeaponsPlugin);
+        app.add_plugins(projectiles::ProjectilesPlugin);
     }
 }

shared/src/weapons.rs → shared/src/projectiles.rs

@@ -1,4 +1,4 @@
-use avian3d::prelude::Position;
+use avian3d::prelude::{Collider, LinearVelocity, Position, RigidBody};
 use bevy::prelude::*;
 use leafwing_input_manager::action_state::ActionState;
 use lightyear::client::prediction::Predicted;
@@ -7,40 +7,52 @@ use lightyear::prelude::server::{Replicate, SyncTarget};
 use crate::player::Player;
 use crate::prelude::{PlayerInput, PREDICTION_REPLICATION_GROUP_ID};
 
-pub(crate) struct WeaponsPlugin;
+pub(crate) struct ProjectilesPlugin;
 
-impl Plugin for WeaponsPlugin {
+impl Plugin for ProjectilesPlugin {
     fn build(&self, app: &mut App) {
         // SYSTEMS
         app.add_systems(FixedUpdate, shoot_projectiles);
     }
 }
 
+// TODO: maybe make this an enum with the type of projectile?
 #[derive(Component, Debug, Clone)]
 pub struct Projectile;
 
+
 /// Shoot projectiles from the current weapon when the shoot action is pressed
 pub(crate) fn shoot_projectiles(
     mut commands: Commands,
     identity: NetworkIdentity,
     query: Query<
         (
             &Player,
-            &Position,
+            &Transform,
             &ActionState<PlayerInput>,
         ),
         Or<(With<Predicted>, With<Replicating>)>,
     >,
 ) {
-    for (player, position, action) in query.iter() {
+    for (player, transform, action) in query.iter() {
 
         // NOTE: pressed lets you shoot many bullets, which can be cool
         if action.just_pressed(&PlayerInput::ShootPrimary) {
+            let direction = transform.forward().as_vec3();
+
+            // offset a little bit from the player
+            let mut new_transform = *transform;
+            new_transform.translation += 0.5 * direction;
             let projectile = (
-                Transform::from_translation(position.0),
+                new_transform,
                 Projectile,
+                // TODO: change projectile speed
+                LinearVelocity(direction * 5.0),
+                // TODO: change projectile shape
+                Collider::sphere(0.1),
                 // the projectile will be spawned on both client (in the predicted timeline) and the server
                 PreSpawnedPlayerObject::default(),
+                RigidBody::Dynamic,
             );
 
             // on the server, spawn and replicate the projectile