bevy-tnua 0.29.0

A floating character controller for Bevy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::ghost_overrides::TnuaGhostOverwritesForBasis;
use crate::{TnuaBasis, TnuaScheme, math::*};
use bevy::prelude::*;
use bevy_tnua_physics_integration_layer::data_for_backends::{
    TnuaGhostSensor, TnuaProximitySensor, TnuaSensorOf,
};

/// The entities that hold the [proximity sensors](TnuaProximitySensor) of the basis.
///
/// Automatically added for [`TnuaController`](crate::TnuaController).
#[derive(Component, Deref)]
pub struct TnuaSensorsEntities<S: TnuaScheme> {
    pub(crate) sensors_entities:
        <<S::Basis as TnuaBasis>::Sensors<'static> as TnuaSensors<'static>>::Entities,
}

pub trait TnuaSensors<'a>: 'a + Copy + Clone {
    type Entities: 'static + Send + Sync + Default;
    #[cfg(feature = "serialize")]
    type GhostOverwrites: TnuaGhostOverwritesForBasis<Entities = Self::Entities>
        + serde::Serialize
        + for<'de> serde::Deserialize<'de>;
    #[cfg(not(feature = "serialize"))]
    type GhostOverwrites: TnuaGhostOverwritesForBasis<Entities = Self::Entities>;
}

pub struct ProximitySensorPreparationHelper {
    pub cast_origin: Vector3,
    pub cast_direction: Dir3,
    pub cast_shape_rotation: Quaternion,
    pub cast_range: Float,
    pub ghost_sensor: bool,
}

impl Default for ProximitySensorPreparationHelper {
    fn default() -> Self {
        Self {
            cast_origin: Vector3::ZERO,
            cast_direction: Dir3::NEG_Y,
            cast_shape_rotation: Quaternion::IDENTITY,
            cast_range: 0.0,
            ghost_sensor: false,
        }
    }
}

impl ProximitySensorPreparationHelper {
    fn already_set_in_sensor(&self, sensor: &TnuaProximitySensor) -> bool {
        let Self {
            cast_origin,
            cast_direction,
            cast_shape_rotation,
            cast_range,
            ghost_sensor: _,
        } = self;
        *cast_origin == sensor.cast_origin
            && *cast_direction == sensor.cast_direction
            && *cast_shape_rotation == sensor.cast_shape_rotation
            && *cast_range == sensor.cast_range
    }

    fn to_sensor(&self) -> TnuaProximitySensor {
        TnuaProximitySensor {
            cast_origin: self.cast_origin,
            cast_direction: self.cast_direction,
            cast_shape_rotation: self.cast_shape_rotation,
            cast_range: self.cast_range,
            output: None,
        }
    }

    pub fn prepare_for<'a>(
        &self,
        put_in_entity: &mut Option<Entity>,
        proximity_sensors_query: &'a Query<(&TnuaProximitySensor, Has<TnuaGhostSensor>)>,
        controller_entity: Entity,
        commands: &mut Commands,
    ) -> Option<&'a TnuaProximitySensor> {
        if let Some(sensor_entity) = put_in_entity
            && let Ok((existing_sensor, has_ghost_sensor)) =
                proximity_sensors_query.get(*sensor_entity)
        {
            if !self.already_set_in_sensor(existing_sensor) {
                // TODO: send a command that only alters the sensor properties?
                commands.entity(*sensor_entity).insert(self.to_sensor());
            }
            if self.ghost_sensor && !has_ghost_sensor {
                commands
                    .entity(*sensor_entity)
                    .insert(TnuaGhostSensor::default());
            } else if !self.ghost_sensor && has_ghost_sensor {
                commands
                    .entity(*sensor_entity)
                    .try_remove::<TnuaGhostSensor>();
            }
            Some(existing_sensor)
        } else {
            commands
                .entity(controller_entity)
                .with_related_entities::<TnuaSensorOf>(|commands| {
                    let mut cmd = commands.spawn(self.to_sensor());
                    if self.ghost_sensor {
                        cmd.insert(TnuaGhostSensor::default());
                    }
                    *put_in_entity = Some(cmd.id());
                });
            None
        }
    }

    pub fn ensure_not_existing<'a>(
        put_in_entity: &mut Option<Entity>,
        proximity_sensors_query: &'a Query<(&TnuaProximitySensor, Has<TnuaGhostSensor>)>,
        commands: &mut Commands,
    ) -> Option<&'a TnuaProximitySensor> {
        if let Some(sensor_entity) = put_in_entity {
            if proximity_sensors_query.contains(*sensor_entity) {
                commands.entity(*sensor_entity).despawn();
            } else {
                *put_in_entity = None;
            }
        }
        None
    }
}