use ProjectileOrigin joint (#36)

src/abilities/arrow.rs

@@ -59,7 +59,7 @@ fn on_trigger_arrow(
     };
 
     let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
-    t.translation += (t.forward().as_vec3() * 2.) + (Vec3::Y * 0.6);
+    t.translation += t.forward().as_vec3() * 2.;
 
     let damage = heads_db.head_stats(state.head).damage;
     commands.spawn((Name::new("projectile-arrow"), ArrowProjectile { damage }, t));

src/abilities/gun.rs

@@ -98,7 +98,7 @@ fn on_trigger_gun(
     };
 
     let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
-    t.translation += (t.forward().as_vec3() * 2.) + (Vec3::Y * 0.6);
+    t.translation += t.forward().as_vec3() * 2.0;
 
     commands
         .spawn((

src/abilities/mod.rs

@@ -4,6 +4,7 @@ mod thrown;
 
 use crate::{
     aim::AimTarget,
+    character::ProjectileOrigin,
     global_observer,
     heads::ActiveHeads,
     heads_database::HeadsDatabase,
@@ -81,10 +82,12 @@ fn on_trigger_state(
     trigger: Trigger<TriggerState>,
     mut commands: Commands,
     player_rot: Query<&Transform, With<PlayerBodyMesh>>,
-    player_query: Query<(&Transform, &AimTarget), With<Player>>,
+    player_query: Query<(Entity, &AimTarget), With<Player>>,
     mut active_heads: Query<&mut ActiveHeads, With<Player>>,
     heads_db: Res<HeadsDatabase>,
     time: Res<Time>,
+    descendants: Query<&Children>,
+    projectile_origin: Query<&GlobalTransform, With<ProjectileOrigin>>,
 ) {
     if matches!(trigger.event(), TriggerState::Active) {
         let Ok(mut active_heads) = active_heads.get_single_mut() else {
@@ -100,10 +103,19 @@ fn on_trigger_state(
             return;
         }
 
-        let Some((transform, target)) = player_query.iter().next() else {
+        let Some((player, target)) = player_query.iter().next() else {
             return;
         };
 
+        let Some(transform) = descendants
+            .iter_descendants(player)
+            .find_map(|child| projectile_origin.get(child).ok())
+        else {
+            return;
+        };
+
+        let projectile_origin = transform.translation();
+
         let Some((rot, dir)) = player_rot.iter().next().map(|t| (t.rotation, t.forward())) else {
             return;
         };
@@ -111,7 +123,7 @@ fn on_trigger_state(
         let trigger_state = TriggerData {
             dir,
             rot,
-            pos: transform.translation,
+            pos: projectile_origin,
             target: target.0,
             target_layer: GameLayer::Npc,
             head: state.head,

src/abilities/thrown.rs

@@ -99,7 +99,7 @@ fn on_trigger_thrown(
 
     const SPEED: f32 = 35.;
 
-    let pos = state.pos + state.dir.as_vec3() * -0.8;
+    let pos = state.pos;
 
     let vel = if let Some(target) = state.target {
         let t = query_transform

src/character.rs

@@ -2,6 +2,9 @@ use crate::{GameState, heads_database::HeadsDatabase, loading_assets::GameAssets
 use bevy::{prelude::*, utils::HashMap};
 use std::time::Duration;
 
+#[derive(Component, Debug)]
+pub struct ProjectileOrigin;
+
 #[derive(Component, Debug)]
 pub struct AnimatedCharacter(pub usize);
 
@@ -17,7 +20,12 @@ pub struct CharacterAnimations {
 pub fn plugin(app: &mut App) {
     app.add_systems(
         Update,
-        (spawn, setup_once_loaded).run_if(in_state(GameState::Playing)),
+        (spawn, setup_once_loaded, setup_projectile_origin).run_if(in_state(GameState::Playing)),
+    );
+    #[cfg(feature = "dbg")]
+    app.add_systems(
+        Update,
+        debug_show_projectile_origin.run_if(in_state(GameState::Playing)),
     );
 }
 
@@ -48,6 +56,24 @@ fn spawn(
     }
 }
 
+fn setup_projectile_origin(
+    mut commands: Commands,
+    query: Query<Entity, Added<AnimationPlayer>>,
+    descendants: Query<&Children>,
+    name: Query<&Name>,
+) {
+    for character in query.iter() {
+        for child in descendants.iter_descendants(character) {
+            let Ok(name) = name.get(child) else {
+                continue;
+            };
+            if name.as_str() == "ProjectileOrigin" {
+                commands.entity(child).insert(ProjectileOrigin);
+            }
+        }
+    }
+}
+
 fn setup_once_loaded(
     mut commands: Commands,
     mut query: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
@@ -100,3 +126,17 @@ fn setup_once_loaded(
             .insert(animations);
     }
 }
+
+#[cfg(feature = "dbg")]
+fn debug_show_projectile_origin(
+    mut gizmos: Gizmos,
+    query: Query<&GlobalTransform, With<ProjectileOrigin>>,
+) {
+    for projectile_origin in query.iter() {
+        gizmos.sphere(
+            Isometry3d::from_translation(projectile_origin.translation()),
+            0.1,
+            Color::linear_rgb(0., 1., 0.),
+        );
+    }
+}