veloren_voxygen/audio/sfx/event_mapper/movement/

mod.rs

/// EventMapper::Movement watches the movement states of surrounding entities,
/// and triggers sfx related to running, climbing and gliding, at a volume
/// proportionate to the extity's size
use super::EventMapper;
use crate::{
    AudioFrontend,
    audio::sfx::{SFX_DIST_LIMIT_SQR, SfxEvent, SfxTag, SfxTriggerItem, SfxTriggers},
    ecs::comp::{Footsteps, Interpolated},
    scene::{Camera, FigureMgr, Terrain},
};
use client::Client;
use common::{
    comp::{Body, CharacterState, PhysicsState, Scale, Vel},
    resources::DeltaTime,
    states,
    terrain::{BlockKind, TerrainChunk},
};
use common_state::State;
use hashbrown::HashMap;
use rand::prelude::*;
use specs::{Entity as EcsEntity, Join, LendJoin, WorldExt};
use std::time::{Duration, Instant};
use vek::*;

#[derive(Clone)]
struct PreviousEntityState {
    event: SfxEvent,
    time: Instant,
    on_ground: bool,
    in_water: bool,
    steps_taken: f32,
    is_stepping: Option<bool>,
}

impl Default for PreviousEntityState {
    fn default() -> Self {
        Self {
            event: SfxEvent::Idle,
            time: Instant::now(),
            on_ground: true,
            in_water: false,
            steps_taken: 0.0,
            is_stepping: None,
        }
    }
}

pub struct MovementEventMapper {
    event_history: HashMap<EcsEntity, PreviousEntityState>,
}

impl EventMapper for MovementEventMapper {
    fn maintain(
        &mut self,
        audio: &mut AudioFrontend,
        state: &State,
        player_entity: specs::Entity,
        camera: &Camera,
        triggers: &SfxTriggers,
        _terrain: &Terrain<TerrainChunk>,
        _client: &Client,
        figure_mgr: &FigureMgr,
    ) {
        let ecs = state.ecs();

        let cam_pos = camera.get_pos_with_focus();

        let mut footsteps = ecs.write_storage::<Footsteps>();
        for (entity, interpolated, vel, body, scale, physics, character) in (
            &ecs.entities(),
            &ecs.read_storage::<Interpolated>(),
            &ecs.read_storage::<Vel>(),
            &ecs.read_storage::<Body>(),
            ecs.read_storage::<Scale>().maybe(),
            &ecs.read_storage::<PhysicsState>(),
            ecs.read_storage::<CharacterState>().maybe(),
        )
            .join()
        {
            // Update footstep detection
            // TODO: Support non-humanoids, remove the old timing logic
            if physics.on_ground.is_some()
                && let Ok(footsteps) = footsteps.entry(entity)
            {
                // Look mom, I found an acceptable use for macros
                macro_rules! update_footsteps {
                    ($($name:ident: $body:ident => [$($foot:ident),* $(,)?]),* $(,)?) => {
                        match body {
                            $(Body::$body(_) => {
                                if let Some(state) = figure_mgr.states.$name.get(&entity) {
                                    let feet_pos = [$(state.computed_skeleton.$foot,)*].map(|f| {
                                        -interpolated.ori.global_to_local(f.mul_point(Vec3::new(0.0, 1.0, -1.0))).y
                                    });
                                    footsteps
                                        .or_insert_with(Default::default)
                                        .update(&feet_pos);
                                }
                            },)*
                            _ => {},
                        }
                    };
                }

                update_footsteps!(
                    character_states: Humanoid => [foot_l, foot_r],
                    biped_large_states: BipedLarge => [foot_l, foot_r],
                    quadruped_medium_states: QuadrupedMedium => [foot_fl, foot_fr, foot_bl, foot_br],
                    quadruped_small_states: QuadrupedSmall => [leg_fl, leg_fr, leg_bl, leg_br],
                    quadruped_low_states: QuadrupedLow => [foot_fl, foot_fr, foot_bl, foot_br],
                    bird_medium_states: BirdMedium => [leg_l, leg_r],
                    bird_large_states: BirdLarge => [foot_l, foot_r],
                    arthropod_states: Arthropod => [
                        leg_fl,
                        leg_fr,
                        leg_fcl,
                        leg_fcr,
                        leg_bcl,
                        leg_bcr,
                        leg_bl,
                        leg_br,
                    ],
                );
            }

            if interpolated.pos.distance_squared(cam_pos) < SFX_DIST_LIMIT_SQR
                && let Some(character) = character
            {
                let internal_state = self.event_history.entry(entity).or_default();

                let mapped_event = match body {
                    Body::Humanoid(_) => {
                        Self::map_movement_event(character, physics, internal_state, vel.0)
                    },
                    Body::QuadrupedMedium(_) | Body::QuadrupedSmall(_) | Body::QuadrupedLow(_) => {
                        Self::map_quadruped_movement_event(physics, internal_state, vel.0)
                    },
                    Body::BirdMedium(_) | Body::BirdLarge(_) | Body::BipedLarge(_) => {
                        Self::map_non_humanoid_movement_event(physics, internal_state, vel.0)
                    },
                    Body::Arthropod(_) => {
                        Self::map_arthropod_movement_event(physics, internal_state, vel.0)
                    },
                    _ => SfxEvent::Idle, // Ignore fish, etc...
                };

                // Check for SFX config entry for this movement
                if Self::should_emit(
                    internal_state,
                    triggers.0.get_key_value(&mapped_event),
                    physics,
                ) {
                    let sfx_trigger_item = triggers.0.get_key_value(&mapped_event);
                    audio.emit_sfx(
                        sfx_trigger_item,
                        interpolated.pos,
                        Some(Self::get_volume_for_body_type(body)),
                        SfxTag::Footstep,
                    );
                    internal_state.time = Instant::now();
                    internal_state.steps_taken = 0.0;
                }

                // update state to determine the next event. We only record the time (above) if
                // it was dispatched
                internal_state.event = mapped_event;
                internal_state.on_ground = physics.on_ground.is_some();
                internal_state.in_water = physics.in_liquid().is_some();
                let dt = ecs.fetch::<DeltaTime>().0;
                internal_state.steps_taken +=
                    vel.0.magnitude() * dt / (body.stride_length() * scale.map_or(1.0, |s| s.0));
                internal_state.is_stepping = footsteps.get(entity).map(|f| f.is_any_stepping());
            }
        }

        self.cleanup(player_entity);
    }
}

impl MovementEventMapper {
    pub fn new() -> Self {
        Self {
            event_history: HashMap::new(),
        }
    }

    /// As the player explores the world, we track the last event of the nearby
    /// entities to determine the correct SFX item to play next based on
    /// their activity. `cleanup` will remove entities from event tracking if
    /// they have not triggered an event for > n seconds. This prevents
    /// stale records from bloating the Map size.
    fn cleanup(&mut self, player: EcsEntity) {
        const TRACKING_TIMEOUT: u64 = 10;

        let now = Instant::now();
        self.event_history.retain(|entity, event| {
            now.duration_since(event.time) < Duration::from_secs(TRACKING_TIMEOUT)
                || entity.id() == player.id()
        });
    }

    /// When specific entity movements are detected, the associated sound (if
    /// any) needs to satisfy two conditions to be allowed to play:
    /// 1. An sfx.ron entry exists for the movement (we need to know which sound
    ///    file(s) to play)
    /// 2. The sfx has not been played since it's timeout threshold has elapsed,
    ///    which prevents firing every tick. For movement, threshold is not a
    ///    time, but a distance.
    fn should_emit(
        previous_state: &PreviousEntityState,
        sfx_trigger_item: Option<(&SfxEvent, &SfxTriggerItem)>,
        physics: &PhysicsState,
    ) -> bool {
        if let Some((event, item)) = sfx_trigger_item {
            let landed = physics.on_ground.is_some() && !previous_state.on_ground;
            // If possible, use the new footstep detection logic
            landed
                || previous_state.is_stepping
                .filter(|_| matches!(event, SfxEvent::Run(_) | SfxEvent::OctoRun(_) | SfxEvent::QuadRun(_)))
                // Otherwise, fall back to simply footstep timers
                .unwrap_or_else(|| match event {
                    SfxEvent::Climb => previous_state.steps_taken >= item.threshold,
                    _ => previous_state.time.elapsed().as_secs_f32() >= item.threshold
                })
        } else {
            false
        }
    }

    /// Voxygen has an existing list of character states; however that list does
    /// not provide enough resolution to target specific entity events, such
    /// as opening or closing the glider. These methods translate those
    /// entity states with some additional data into more specific
    /// `SfxEvent`'s which we attach sounds to
    fn map_movement_event(
        character_state: &CharacterState,
        physics_state: &PhysicsState,
        previous_state: &PreviousEntityState,
        vel: Vec3<f32>,
    ) -> SfxEvent {
        // Match run / roll / swim state
        if physics_state.in_liquid().is_some() && vel.magnitude() > 2.0
            || !previous_state.in_water && physics_state.in_liquid().is_some()
        {
            return SfxEvent::Swim;
        } else if let Some(block) = physics_state.on_ground
            && (vel.magnitude() > 0.1 || !previous_state.on_ground)
        {
            return if let CharacterState::Roll(data) = character_state {
                if data.static_data.was_cancel {
                    SfxEvent::RollCancel
                } else {
                    SfxEvent::Roll
                }
            } else if character_state.is_stealthy() {
                SfxEvent::Sneak
            } else {
                match block.kind() {
                    BlockKind::Snow | BlockKind::ArtSnow => SfxEvent::Run(BlockKind::Snow),
                    BlockKind::Rock
                    | BlockKind::WeakRock
                    | BlockKind::GlowingRock
                    | BlockKind::GlowingWeakRock
                    | BlockKind::Ice => SfxEvent::Run(BlockKind::Rock),
                    BlockKind::Earth => SfxEvent::Run(BlockKind::Earth),
                    // BlockKind::Sand => SfxEvent::Run(BlockKind::Sand),
                    BlockKind::Air => SfxEvent::Idle,
                    _ => SfxEvent::Run(BlockKind::Grass),
                }
            };
        }

        // Match all other Movemement and Action states
        match (previous_state.event.clone(), character_state) {
            (_, CharacterState::Climb { .. }) => SfxEvent::Climb,
            (_, CharacterState::Glide(glide))
                if matches!(glide.booster, Some(states::glide::Boost::Forward(_))) =>
            {
                if rand::rng().random_bool(0.5) {
                    SfxEvent::FlameThrower
                } else {
                    SfxEvent::Idle
                }
            },
            (_, CharacterState::Glide(_)) => SfxEvent::Glide,
            _ => SfxEvent::Idle,
        }
    }

    /// Maps a limited set of movements for other non-humanoid entities
    fn map_non_humanoid_movement_event(
        physics_state: &PhysicsState,
        previous_state: &PreviousEntityState,
        vel: Vec3<f32>,
    ) -> SfxEvent {
        if physics_state.in_liquid().is_some()
            && (vel.magnitude() > 2.0 || !previous_state.on_ground)
        {
            SfxEvent::Swim
        } else if let Some(block) = physics_state.on_ground
            && vel.magnitude() > 0.1
        {
            match block.kind() {
                BlockKind::Snow | BlockKind::ArtSnow => SfxEvent::Run(BlockKind::Snow),
                BlockKind::Rock
                | BlockKind::WeakRock
                | BlockKind::GlowingRock
                | BlockKind::GlowingWeakRock
                | BlockKind::Ice => SfxEvent::Run(BlockKind::Rock),
                // BlockKind::Sand => SfxEvent::Run(BlockKind::Sand),
                BlockKind::Earth => SfxEvent::Run(BlockKind::Earth),
                BlockKind::Air => SfxEvent::Idle,
                _ => SfxEvent::Run(BlockKind::Grass),
            }
        } else {
            SfxEvent::Idle
        }
    }

    /// Maps a limited set of movements for quadruped entities
    fn map_quadruped_movement_event(
        physics_state: &PhysicsState,
        previous_state: &PreviousEntityState,
        vel: Vec3<f32>,
    ) -> SfxEvent {
        if physics_state.in_liquid().is_some()
            && (vel.magnitude() > 2.0 || !previous_state.on_ground)
        {
            SfxEvent::Swim
        } else if let Some(block) = physics_state.on_ground
            && vel.magnitude() > 0.1
        {
            match block.kind() {
                BlockKind::Snow | BlockKind::ArtSnow => SfxEvent::QuadRun(BlockKind::Snow),
                BlockKind::Rock
                | BlockKind::WeakRock
                | BlockKind::GlowingRock
                | BlockKind::GlowingWeakRock
                | BlockKind::Ice => SfxEvent::QuadRun(BlockKind::Rock),
                // BlockKind::Sand => SfxEvent::QuadRun(BlockKind::Sand),
                BlockKind::Earth => SfxEvent::QuadRun(BlockKind::Earth),
                BlockKind::Air => SfxEvent::Idle,
                _ => SfxEvent::QuadRun(BlockKind::Grass),
            }
        } else {
            SfxEvent::Idle
        }
    }

    /// Maps a limited set of movements for arthropod entities
    fn map_arthropod_movement_event(
        physics_state: &PhysicsState,
        previous_state: &PreviousEntityState,
        vel: Vec3<f32>,
    ) -> SfxEvent {
        if physics_state.in_liquid().is_some()
            && (vel.magnitude() > 2.0 || !previous_state.on_ground)
        {
            SfxEvent::Swim
        } else if let Some(block) = physics_state.on_ground
            && vel.magnitude() > 0.1
        {
            match block.kind() {
                BlockKind::Snow | BlockKind::ArtSnow => SfxEvent::OctoRun(BlockKind::Snow),
                BlockKind::Rock
                | BlockKind::WeakRock
                | BlockKind::GlowingRock
                | BlockKind::GlowingWeakRock
                | BlockKind::Ice => SfxEvent::OctoRun(BlockKind::Rock),
                // BlockKind::Sand => SfxEvent::OctoRun(BlockKind::Sand),
                BlockKind::Earth => SfxEvent::OctoRun(BlockKind::Earth),
                BlockKind::Air => SfxEvent::Idle,
                _ => SfxEvent::OctoRun(BlockKind::Grass),
            }
        } else {
            SfxEvent::Idle
        }
    }

    /// Returns a relative volume value for a body type. This helps us emit sfx
    /// at a volume appropriate fot the entity we are emitting the event for
    fn get_volume_for_body_type(body: &Body) -> f32 {
        match body {
            Body::Humanoid(_) => 0.5,
            Body::QuadrupedSmall(_) => 0.2,
            Body::QuadrupedMedium(_) => 0.7,
            Body::QuadrupedLow(_) => 0.7,
            Body::BirdMedium(_) => 0.3,
            Body::BirdLarge(_) => 0.5,
            Body::BipedLarge(_) => 1.0,
            _ => 0.9,
        }
    }
}

#[cfg(test)] mod tests;