summon an

assets/common/abilities/ability_set_manifest.ron

@@ -235,6 +235,13 @@
             (None, "common.abilities.custom.arthropodbasic.leap"),
         ],
     ),
+    Custom("Arthropod Ranged"): (
+        primary: "common.abilities.custom.arthropodranged.singlestrike",
+        secondary: "common.abilities.custom.arthropodranged.ensnaringweb",
+        abilities: [
+            (None, "common.abilities.custom.arthropodranged.poisonball"),
+        ],
+    ),
     Custom("Arthropod Charge"): (
         primary: "common.abilities.custom.arthropodcharge.singlestrike",
         secondary: "common.abilities.custom.arthropodcharge.charge",

assets/common/abilities/custom/arthropodranged/ensnaringweb.ron

@@ -0,0 +1,8 @@
+SpriteSummon(
+    buildup_duration: 0.6,
+    cast_duration: 0.4,
+    recover_duration: 0.3,
+    sprite: EnsnaringWeb,
+    summon_distance: (0, 8),
+    sparseness: 0.67,
+)

assets/common/abilities/custom/arthropodranged/poisonball.ron

@@ -0,0 +1,18 @@
+BasicRanged(
+    energy_cost: 0,
+    buildup_duration: 0.8,
+    recover_duration: 0.35,
+    projectile: NecroticSphere(
+        damage: 26.0,
+        radius: 5.0,
+        energy_regen: 0,
+    ),
+    projectile_body: Object(FireworkPurple),
+    /*projectile_light: Some(LightEmitter {
+        col: (1.0, 0.75, 0.11).into(),
+        ..Default::default()
+    }),*/
+    projectile_speed: 70.0,
+    num_projectiles: 3,
+    projectile_spread: 0.2,
+)

assets/common/abilities/custom/arthropodranged/singlestrike.ron

@@ -0,0 +1,34 @@
+ComboMelee(
+    stage_data: [
+        (
+            stage: 1,
+            base_damage: 100,
+            damage_increase: 0,
+            base_poise_damage: 28,
+            poise_damage_increase: 0,
+            knockback: 3.0,
+            range: 3.0,
+            angle: 60.0,
+            base_buildup_duration: 0.4,
+            base_swing_duration: 0.1,
+            hit_timing: 0.5,
+            base_recover_duration: 0.4,
+            forward_movement: 1.0,
+            damage_kind: Crushing,
+            damage_effect: Some(Buff((
+                kind: Poisoned,
+                dur_secs: 10.0,
+                strength: DamageFraction(1.0),
+                chance: 1.0,
+            ))),
+        ),
+    ],
+    initial_energy_gain: 0,
+    max_energy_gain: 0,
+    energy_increase: 0,
+    speed_increase: 0.0,
+    max_speed_increase: 0.0,
+    scales_from_combo: 0,
+    is_interruptible: false,
+    ori_modifier: 0.7,
+)

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

@@ -0,0 +1,21 @@
+ItemDef(
+    name: "Arthropod Ranged",
+    description: "testing123",
+    kind: Tool((
+        kind: Natural,
+        hands: Two,
+        stats: Direct((
+            equip_time_secs: 0.01,
+            power: 1.0,
+            effect_power: 1.0,
+            speed: 1.0,
+            crit_chance: 0.1,
+            range: 1.0,
+            energy_efficiency: 1.0,
+            buff_strength: 1.0,
+        )),
+    )),
+    quality: Low,
+    tags: [],
+    ability_spec: Some(Custom("Arthropod Ranged")),
+)

common/src/comp/inventory/loadout_builder.rs

@@ -271,6 +271,10 @@ fn default_main_tool(body: &Body) -> Item {
             | arthropod::Species::Antlion => Some(Item::new_from_asset_expect(
                 "common.items.npc_weapons.unique.arthropodcharge",
             )),
+            arthropod::Species::Cavespider
+             => Some(Item::new_from_asset_expect(
+                "common.items.npc_weapons.unique.arthropodranged",
+            )),
             _ => Some(Item::new_from_asset_expect(
                 "common.items.npc_weapons.unique.arthropodbasic",
             )),

voxygen/anim/src/arthropod/mod.rs

@@ -4,12 +4,15 @@ pub mod idle;
 pub mod jump;
 pub mod leapmelee;
 pub mod run;
+pub mod shoot;
 pub mod stunned;
+pub mod summon;
 
 // Reexports
 pub use self::{
     alpha::AlphaAnimation, dash::DashAnimation, idle::IdleAnimation, jump::JumpAnimation,
-    leapmelee::LeapMeleeAnimation, run::RunAnimation, stunned::StunnedAnimation,
+    leapmelee::LeapMeleeAnimation, run::RunAnimation, shoot::ShootAnimation, stunned::StunnedAnimation,
+    summon::SummonAnimation,
 };
 
 use super::{make_bone, vek::*, FigureBoneData, Offsets, Skeleton};

voxygen/anim/src/arthropod/shoot.rs

@@ -0,0 +1,103 @@
+use std::f32::consts::PI;
+
+use super::{
+    super::{vek::*, Animation},
+    ArthropodSkeleton, SkeletonAttr,
+};
+use common::states::utils::StageSection;
+
+pub struct ShootAnimation;
+
+impl Animation for ShootAnimation {
+    type Dependency<'a> = (f32, f32, Option<StageSection>, f32);
+    type Skeleton = ArthropodSkeleton;
+
+    #[cfg(feature = "use-dyn-lib")]
+    const UPDATE_FN: &'static [u8] = b"arthropod_shoot\0";
+
+    #[cfg_attr(feature = "be-dyn-lib", export_name = "arthropod_shoot")]
+    fn update_skeleton_inner<'a>(
+        skeleton: &Self::Skeleton,
+        (_velocity, global_time, stage_section, timer): Self::Dependency<'a>,
+        anim_time: f32,
+        _rate: &mut f32,
+        s_a: &SkeletonAttr,
+    ) -> Self::Skeleton {
+        let mut next = (*skeleton).clone();
+
+        let (movement1, movement2) = match stage_section {
+            Some(StageSection::Buildup) => (anim_time.powi(2), 0.0),
+            Some(StageSection::Recover) => (1.0, anim_time),
+            _ => (0.0, 0.0),
+        };
+        let pullback = 1.0 - movement2;
+        let subtract = global_time - timer;
+        let check = subtract - subtract.trunc();
+        let mirror = (check - 0.5).signum();
+        //let movement1 = mirror * movement1base * pullback;
+        //let movement2 = mirror * movement2base * pullback;
+        let movement1abs = movement1 * pullback;
+
+
+            next.chest.scale = Vec3::one() / s_a.scaler;
+            next.chest.orientation = Quaternion::rotation_x(0.0)
+                * Quaternion::rotation_z(0.0);
+
+            next.head.position = Vec3::new(0.0, s_a.head.0, s_a.head.1);
+            next.head.orientation =
+                Quaternion::rotation_x(
+                    movement1*0.35 ,
+                ) * Quaternion::rotation_y(
+                    0.0 ,
+                ) ;//* Quaternion::rotation_z((movement1abs * 4.0 * PI).sin() * 0.02);
+
+            next.chest.position = Vec3::new(0.0, s_a.chest.0, s_a.chest.1);
+
+            next.mandible_l.position = Vec3::new(-s_a.mandible.0, s_a.mandible.1, s_a.mandible.2);
+            next.mandible_r.position = Vec3::new(s_a.mandible.0, s_a.mandible.1, s_a.mandible.2);
+            next.mandible_l.orientation = Quaternion::rotation_x(
+                movement1abs * 0.5  ,
+            ) * Quaternion::rotation_y(
+                movement1abs * 0.5  ,
+            )* Quaternion::rotation_z(
+                movement1abs * 0.5  ,
+            );
+            next.mandible_r.orientation = Quaternion::rotation_x(
+                movement1abs * 0.5  ,
+            ) * Quaternion::rotation_y(
+                movement1abs * -0.5  ,
+            )* Quaternion::rotation_z(
+                movement1abs * -0.5  ,
+            );
+
+            next.wing_fl.position = Vec3::new(-s_a.wing_f.0, s_a.wing_f.1, s_a.wing_f.2);
+            next.wing_fr.position = Vec3::new(s_a.wing_f.0, s_a.wing_f.1, s_a.wing_f.2);
+
+            next.wing_bl.position = Vec3::new(-s_a.wing_b.0, s_a.wing_b.1, s_a.wing_b.2);
+            next.wing_br.position = Vec3::new(s_a.wing_b.0, s_a.wing_b.1, s_a.wing_b.2);
+
+            next.leg_fl.position = Vec3::new(-s_a.leg_f.0, s_a.leg_f.1, s_a.leg_f.2);
+            next.leg_fr.position = Vec3::new(s_a.leg_f.0, s_a.leg_f.1, s_a.leg_f.2);
+            next.leg_fl.orientation = Quaternion::rotation_z(
+                s_a.leg_ori.0 + movement1abs * 0.4  ,
+            ) * Quaternion::rotation_x(
+                movement1abs * 1.0,
+            );
+            next.leg_fr.orientation = Quaternion::rotation_z(
+                -s_a.leg_ori.0  + movement1abs * -0.4 ,
+            ) * Quaternion::rotation_x(
+                movement1abs * 1.0,
+            );
+
+            next.leg_fcl.position = Vec3::new(-s_a.leg_fc.0, s_a.leg_fc.1, s_a.leg_fc.2);
+            next.leg_fcr.position = Vec3::new(s_a.leg_fc.0, s_a.leg_fc.1, s_a.leg_fc.2);
+
+            next.leg_bcl.position = Vec3::new(-s_a.leg_bc.0, s_a.leg_bc.1, s_a.leg_bc.2);
+            next.leg_bcr.position = Vec3::new(s_a.leg_bc.0, s_a.leg_bc.1, s_a.leg_bc.2);
+
+            next.leg_bl.position = Vec3::new(-s_a.leg_b.0, s_a.leg_b.1, s_a.leg_b.2);
+            next.leg_br.position = Vec3::new(s_a.leg_b.0, s_a.leg_b.1, s_a.leg_b.2);
+
+        next
+    }
+}

voxygen/anim/src/arthropod/summon.rs

@@ -0,0 +1,109 @@
+use std::f32::consts::PI;
+
+use super::{
+    super::{vek::*, Animation},
+    ArthropodSkeleton, SkeletonAttr,
+};
+use common::states::utils::StageSection;
+
+pub struct SummonAnimation;
+
+impl Animation for SummonAnimation {
+    type Dependency<'a> = (f32, f32, Option<StageSection>, f32);
+    type Skeleton = ArthropodSkeleton;
+
+    #[cfg(feature = "use-dyn-lib")]
+    const UPDATE_FN: &'static [u8] = b"arthropod_summon\0";
+
+    #[cfg_attr(feature = "be-dyn-lib", export_name = "arthropod_summon")]
+    fn update_skeleton_inner<'a>(
+        skeleton: &Self::Skeleton,
+        (_velocity, global_time, stage_section, timer): Self::Dependency<'a>,
+        anim_time: f32,
+        _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.powi(2), 0.0, 0.0),
+            Some(StageSection::Action) => (1.0, anim_time.powi(4), 0.0),
+            Some(StageSection::Recover) => (1.0, 1.0, anim_time),
+            _ => (0.0, 0.0, 0.0),
+        };
+        let pullback = 1.0 - movement3;
+        let subtract = global_time - timer;
+        let check = subtract - subtract.trunc();
+        let mirror = (check - 0.5).signum();
+        //let movement1 = mirror * movement1base * pullback;
+        //let movement2 = mirror * movement2base * pullback;
+        let movement1abs = movement1 * pullback;
+        let movement2abs = movement2 * pullback;
+        let movement3abs = movement3 * pullback;
+
+        next.chest.scale = Vec3::one() / s_a.scaler;
+        next.chest.orientation = Quaternion::rotation_x(movement2abs * 0.3)
+            * Quaternion::rotation_z((movement1abs * 4.0 * PI).sin() * 0.02);
+
+        next.head.position = Vec3::new(
+            0.0,
+            s_a.head.0 + movement1abs * 3.0,
+            s_a.head.1 + movement1abs * -3.0,
+        );
+        next.head.orientation =
+            Quaternion::rotation_x(movement1abs * 1.5 + movement2abs * -1.5 + movement3abs * 0.8)
+                * Quaternion::rotation_y(
+                    mirror * movement1abs * -0.2 + mirror * movement2abs * 0.2,
+                )
+                * Quaternion::rotation_z((movement1abs * 4.0 * PI).sin() * 0.02);
+
+        next.chest.position = Vec3::new(
+            0.0,
+            s_a.chest.0,
+            s_a.chest.1 + movement1abs * 7.0 + movement2abs * -2.0,
+        );
+        next.chest.orientation = Quaternion::rotation_x(movement1abs * -1.0 + movement2abs * 0.2);
+        next.mandible_l.position = Vec3::new(-s_a.mandible.0, s_a.mandible.1, s_a.mandible.2);
+        next.mandible_r.position = Vec3::new(s_a.mandible.0, s_a.mandible.1, s_a.mandible.2);
+        next.mandible_l.orientation =
+            Quaternion::rotation_x(movement1abs * 0.5 + movement2abs * -1.5 + movement3abs * 0.8)
+                * Quaternion::rotation_z(
+                    movement1abs * 0.5 + movement2abs * -0.6 + movement3abs * 0.8,
+                );
+        next.mandible_r.orientation =
+            Quaternion::rotation_x(movement1abs * 0.5 + movement2abs * -1.5 + movement3abs * 0.8)
+                * Quaternion::rotation_z(
+                    movement1abs * -0.5 + movement2abs * 0.6 + movement3abs * -0.8,
+                );
+
+        next.leg_fl.position = Vec3::new(-s_a.leg_f.0, s_a.leg_f.1, s_a.leg_f.2);
+        next.leg_fr.position = Vec3::new(s_a.leg_f.0, s_a.leg_f.1, s_a.leg_f.2);
+        next.leg_fl.orientation = Quaternion::rotation_x(movement1abs * 1.0 + movement2abs * 0.2)
+            * Quaternion::rotation_z(movement1abs * -0.2 + movement2abs * -0.2);
+        next.leg_fr.orientation = Quaternion::rotation_x(movement1abs * 1.0 + movement2abs * 0.2)
+            * Quaternion::rotation_x(movement1abs * 0.2 + movement2abs * 0.2);
+
+        next.leg_fcl.position = Vec3::new(-s_a.leg_fc.0, s_a.leg_fc.1, s_a.leg_fc.2);
+        next.leg_fcr.position = Vec3::new(s_a.leg_fc.0, s_a.leg_fc.1, s_a.leg_fc.2);
+
+        next.leg_fcl.orientation = Quaternion::rotation_x(movement1abs * 1.3 + movement2abs * 0.3)
+            * Quaternion::rotation_z(movement1abs * -0.5 + movement2abs * -0.2);
+        next.leg_fcr.orientation = Quaternion::rotation_x(movement1abs * 1.3 + movement2abs * 0.3)
+            * Quaternion::rotation_z(movement1abs * 0.5 + movement2abs * -0.2);
+
+        next.leg_bcl.position = Vec3::new(-s_a.leg_bc.0, s_a.leg_bc.1, s_a.leg_bc.2);
+        next.leg_bcr.position = Vec3::new(s_a.leg_bc.0, s_a.leg_bc.1, s_a.leg_bc.2);
+
+        next.leg_bcl.orientation = Quaternion::rotation_x(movement1abs * 0.5 + movement2abs * 0.2);
+        next.leg_bcr.orientation = Quaternion::rotation_x(movement1abs * 0.5 + movement2abs * 0.2);
+
+        next.leg_bl.position = Vec3::new(-s_a.leg_b.0, s_a.leg_b.1, s_a.leg_b.2);
+        next.leg_br.position = Vec3::new(s_a.leg_b.0, s_a.leg_b.1, s_a.leg_b.2);
+
+        next.leg_bl.orientation = Quaternion::rotation_x(movement1abs * -0.5 + movement2abs * -0.2)
+            * Quaternion::rotation_z(movement1abs * 0.8);
+        next.leg_br.orientation = Quaternion::rotation_x(movement1abs * -0.5 + movement2abs * -0.2)
+            * Quaternion::rotation_z(movement1abs * -0.8);
+        next
+    }
+}

voxygen/src/scene/figure/mod.rs

@@ -3604,6 +3604,33 @@ impl FigureMgr {
                                 skeleton_attr,
                             )
                         },
+                        CharacterState::SpriteSummon(s) => {
+                            let stage_time = s.timer.as_secs_f32();
+                            let stage_progress = match s.stage_section {
+                                StageSection::Buildup => {
+                                    stage_time / s.static_data.buildup_duration.as_secs_f32()
+                                },
+                                StageSection::Action => {
+                                    stage_time / s.static_data.cast_duration.as_secs_f32()
+                                },
+                                StageSection::Recover => {
+                                    stage_time / s.static_data.recover_duration.as_secs_f32()
+                                },
+                                _ => 0.0,
+                            };
+                            anim::arthropod::SummonAnimation::update_skeleton(
+                                &target_base,
+                                (
+                                    rel_vel.magnitude(),
+                                    time,
+                                    Some(s.stage_section),
+                                    state.state_time,
+                                ),
+                                stage_progress,
+                                &mut state_animation_rate,
+                                skeleton_attr,
+                            )
+                        },
                         CharacterState::DashMelee(s) => {
                             let stage_time = s.timer.as_secs_f32();
                             let stage_progress = match s.stage_section {
@@ -3634,6 +3661,30 @@ impl FigureMgr {
                                 skeleton_attr,
                             )
                         },
+                        CharacterState::BasicRanged(s) => {
+                            let stage_time = s.timer.as_secs_f32();
+                            let stage_progress = match s.stage_section {
+                                StageSection::Buildup => {
+                                    stage_time / s.static_data.buildup_duration.as_secs_f32()
+                                },
+                                StageSection::Recover => {
+                                    stage_time / s.static_data.recover_duration.as_secs_f32()
+                                },
+                                _ => 0.0,
+                            };
+                            anim::arthropod::ShootAnimation::update_skeleton(
+                                &target_base,
+                                (
+                                    rel_vel.magnitude(),
+                                    time,
+                                    Some(s.stage_section),
+                                    state.state_time,
+                                ),
+                                stage_progress,
+                                &mut state_animation_rate,
+                                skeleton_attr,
+                            )
+                        },
                         CharacterState::Stunned(s) => {
                             let stage_time = s.timer.as_secs_f32();
                             let stage_progress = match s.stage_section {