initial quadlow ranged work

assets/common/abilities/unique/quadlowranged/basic.ron

@@ -0,0 +1,18 @@
+BasicRanged(
+    energy_cost: 0,
+    buildup_duration: 800,
+    recover_duration: 350,
+    projectile: Fireball(
+        damage: 100.0,
+        radius: 5.0,
+        energy_regen: 50,
+    ),
+    projectile_body: Object(BoltFire),
+    /*projectile_light: Some(LightEmitter {
+        col: (1.0, 0.75, 0.11).into(),
+        ..Default::default()
+    }),*/
+    projectile_gravity: Some(Gravity(0.9)),
+    projectile_speed: 60.0,
+    can_continue: true,
+)

assets/common/items/npc_weapons/unique/quadlowranged.ron

@@ -0,0 +1,13 @@
+ItemDef(
+    name: "Quad Low Ranged",
+    description: "testing123",
+    kind: Tool(
+        (
+            kind: Unique(QuadLowRanged),
+            stats: (
+                equip_time_millis: 10,
+                power: 1.00),
+        )
+    ),
+    quality: Low,
+)

common/src/comp/inventory/item/tool.rs

@@ -173,4 +173,5 @@ pub enum UniqueKind {
     StoneGolemFist,
     BeastClaws,
     GenericQuadMed,
+    QuadLowRanged,
 }

common/src/loadout_builder.rs

@@ -1,7 +1,7 @@
 use crate::comp::{
     biped_large, golem,
     item::{tool::AbilityMap, Item, ItemKind},
-    quadruped_medium, Body, CharacterAbility, ItemConfig, Loadout,
+    quadruped_low, quadruped_medium, Body, CharacterAbility, ItemConfig, Loadout,
 };
 use rand::Rng;
 
@@ -111,6 +111,14 @@ impl LoadoutBuilder {
                     },
                     _ => {},
                 },
+                Body::QuadrupedLow(quadruped_low) => match quadruped_low.species {
+                    quadruped_low::Species::Maneater => {
+                        main_tool = Some(Item::new_from_asset_expect(
+                            "common.items.npc_weapons.unique.quadlowranged",
+                        ));
+                    },
+                    _ => {},
+                },
                 Body::BipedLarge(biped_large) => match (biped_large.species, biped_large.body_type)
                 {
                     (biped_large::Species::Occultsaurok, _) => {

common/src/sys/agent.rs

@@ -352,6 +352,8 @@ impl<'a> System<'a> for Sys {
                                 Tactic::StoneGolemBoss
                             },
                             Some(ToolKind::Unique(UniqueKind::GenericQuadMed)) => Tactic::Wolf,
+                            Some(ToolKind::Unique(UniqueKind::QuadLowRanged)) => Tactic::Staff,
+
                             _ => Tactic::Melee,
                         };
 

voxygen/src/anim/src/quadruped_low/mod.rs

@@ -2,10 +2,12 @@ pub mod alpha;
 pub mod idle;
 pub mod jump;
 pub mod run;
+pub mod shoot;
 
 // Reexports
 pub use self::{
     alpha::AlphaAnimation, idle::IdleAnimation, jump::JumpAnimation, run::RunAnimation,
+    shoot::ShootAnimation,
 };
 
 use super::{make_bone, vek::*, FigureBoneData, Skeleton};

voxygen/src/anim/src/quadruped_low/shoot.rs

@@ -0,0 +1,65 @@
+use super::{
+    super::{vek::*, Animation},
+    QuadrupedLowSkeleton, SkeletonAttr,
+};
+use common::states::utils::StageSection;
+
+pub struct ShootAnimation;
+
+impl Animation for ShootAnimation {
+    type Dependency = (f32, f64, Option<StageSection>);
+    type Skeleton = QuadrupedLowSkeleton;
+
+    #[cfg(feature = "use-dyn-lib")]
+    const UPDATE_FN: &'static [u8] = b"quadruped_low_shoot\0";
+
+    #[cfg_attr(feature = "be-dyn-lib", export_name = "quadruped_low_shoot")]
+    fn update_skeleton_inner(
+        skeleton: &Self::Skeleton,
+        (velocity, _global_time, stage_section): Self::Dependency,
+        anim_time: f64,
+        _rate: &mut f32,
+        s_a: &SkeletonAttr,
+    ) -> Self::Skeleton {
+        let mut next = (*skeleton).clone();
+
+        let (movement1, movement2, movement3) = match stage_section {
+            Some(StageSection::Buildup) => (anim_time as f32, 0.0, 0.0),
+            Some(StageSection::Swing) => (1.0, (anim_time as f32).powf(0.25), 0.0),
+            Some(StageSection::Recover) => (1.0, 1.0, anim_time as f32),
+            _ => (0.0, 0.0, 0.0),
+        };
+
+        let twitch1 = (movement1 * 18.0).sin();
+        next.head_upper.position = Vec3::new(0.0, s_a.head_upper.0, s_a.head_upper.1);
+        next.head_upper.orientation =
+            Quaternion::rotation_x((movement1 * 0.6 + movement2 * 0.7) * (1.0 - movement3))
+                * Quaternion::rotation_z((twitch1 * 0.1) * (1.0 - movement3));
+
+        next.head_lower.position = Vec3::new(0.0, s_a.head_lower.0, s_a.head_lower.1);
+        next.head_lower.orientation = Quaternion::rotation_x(movement2 * 0.3 * (1.0 - movement3));
+
+        next.jaw.position = Vec3::new(0.0, s_a.jaw.0, s_a.jaw.1);
+        next.jaw.orientation = Quaternion::rotation_x(movement1 * -0.5);
+
+        next.chest.position = Vec3::new(0.0, s_a.chest.0, s_a.chest.1) * s_a.scaler / 11.0;
+        next.chest.orientation = Quaternion::rotation_x(0.0);
+
+        next.tail_front.position = Vec3::new(0.0, s_a.tail_front.0, s_a.tail_front.1);
+        next.tail_front.orientation = Quaternion::rotation_x(movement1 * 0.15);
+
+        next.tail_rear.position = Vec3::new(0.0, s_a.tail_rear.0, s_a.tail_rear.1);
+        next.tail_rear.orientation = Quaternion::rotation_x(0.0);
+        if velocity < 0.5 {
+            next.foot_fl.position = Vec3::new(-s_a.feet_f.0, s_a.feet_f.1, s_a.feet_f.2);
+
+            next.foot_fr.position = Vec3::new(s_a.feet_f.0, s_a.feet_f.1, s_a.feet_f.2);
+
+            next.foot_bl.position = Vec3::new(-s_a.feet_b.0, s_a.feet_b.1, s_a.feet_b.2);
+
+            next.foot_br.position = Vec3::new(s_a.feet_b.0, s_a.feet_b.1, s_a.feet_b.2);
+        } else {
+        };
+        next
+    }
+}

voxygen/src/anim/src/quadruped_medium/alpha.rs

@@ -2,8 +2,7 @@ use super::{
     super::{vek::*, Animation},
     QuadrupedMediumSkeleton, SkeletonAttr,
 };
-use common::{comp::item::ToolKind, states::utils::StageSection};
-use std::f32::consts::PI;
+use common::states::utils::StageSection;
 
 pub struct AlphaAnimation;
 

voxygen/src/scene/figure/mod.rs

@@ -1660,11 +1660,23 @@ impl FigureMgr {
                         ),
                     };
                     let target_bones = match &character {
-                        CharacterState::BasicMelee(_) => {
-                            anim::quadruped_low::AlphaAnimation::update_skeleton(
+                        CharacterState::BasicRanged(s) => {
+                            let stage_time = s.timer.as_secs_f64();
+
+                            let stage_progress = match s.stage_section {
+                                StageSection::Buildup => {
+                                    stage_time / s.static_data.buildup_duration.as_secs_f64()
+                                },
+                                StageSection::Recover => {
+                                    stage_time / s.static_data.recover_duration.as_secs_f64()
+                                },
+
+                                _ => 0.0,
+                            };
+                            anim::quadruped_low::ShootAnimation::update_skeleton(
                                 &target_base,
-                                (vel.0.magnitude(), time),
-                                state.state_time,
+                                (vel.0.magnitude(), time, Some(s.stage_section)),
+                                stage_progress,
                                 &mut state_animation_rate,
                                 skeleton_attr,
                             )