yurei 0.2.26

a WIP high level wrapper around bevy_rapier3d created to remove some of the boilerplate while prototyping 3d platformers with 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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use bevy::prelude::*;
use bevy_rapier3d::prelude::*;

/// Marker component that indicates if a character is currently on the ground
#[derive(Component)]
pub struct Grounded;

/// Component attached to any character that want's to move itself towards a target using forces
#[derive(Reflect, Component, Default)]
#[reflect(Component)]
pub struct Movement {
    pub goal_velocity: Vec3,
    pub direction: Vec3,
    pub acceleration: f32,
    pub top_speed: f32,
    pub deceleration: f32,
}

/// Marker that indicates a body should rotate based on the direction of an attached [Movement]
/// component
#[derive(Component)]
pub struct RotationDriver;

/// Component that controls making characters hover slightly above the ground
#[derive(Reflect, Component)]
#[reflect(Component)]
pub struct Hover {
    pub ray_length: f32,
    pub ride_height: f32,
    pub strength: f32,
    pub damper: f32,
}

impl Hover {
    pub fn calculate_spring_force(&self, distance: f32, linear_velocity: Vec3) -> f32 {
        let ray_direction = Vec3::Y * -1.0;
        let ray_direction_velocity = ray_direction.dot(linear_velocity);
        let opposite_relative = ray_direction.dot(Vec3::ZERO);
        let relative_velocity = ray_direction_velocity - opposite_relative;
        let force_direction = distance - self.ride_height;
        let up_force = force_direction * self.strength;
        let damping_force = relative_velocity * self.damper;
        let spring_force = up_force - damping_force;
        spring_force * -1.0
    }
}

impl Default for Hover {
    fn default() -> Self {
        Hover {
            ray_length: 4.0,
            ride_height: 2.8,
            strength: 900.0,
            damper: 60.0,
        }
    }
}

#[derive(Component)]
pub struct MovingPlatformDriver {
    pub targets: Vec<Vec3>,
    pub target_index: usize,
    pub distance_threshhold: f32,
    pub moving: bool,
}

impl MovingPlatformDriver {
    pub fn with_targets(targets: Vec<Vec3>) -> Self {
        MovingPlatformDriver {
            targets,
            ..default()
        }
    }

    pub fn current_target_location(&self) -> Vec3 {
        self.targets[self.target_index]
    }

    pub fn update(&mut self, current_position: Vec3) {
        if self.should_cycle(current_position) {
            self.cycle_targets();
        }
    }

    fn should_cycle(&self, current_position: Vec3) -> bool {
        self.distance_to_target(current_position) < self.distance_threshhold
    }

    fn distance_to_target(&self, current_position: Vec3) -> f32 {
        self.targets[self.target_index].distance(current_position)
    }

    fn cycle_targets(&mut self) {
        let new_index = self.target_index + 1;
        if new_index > self.targets.len() - 1 {
            self.target_index = 0;
        } else {
            self.target_index = new_index;
        }
    }
}

impl Default for MovingPlatformDriver {
    fn default() -> Self {
        MovingPlatformDriver {
            targets: Vec::new(),
            target_index: 0,
            distance_threshhold: 0.2,
            moving: true,
        }
    }
}

/// Bundle containing all of the necessary components to allow force based movement/rotation for a
/// character
#[derive(Bundle)]
pub struct YureiBundle {
    pub rigidbody: RigidBody,
    pub velocity: Velocity,
    pub external_force: ExternalForce,
    pub external_impulse: ExternalImpulse,
    pub locked_axes: LockedAxes,
    pub hover: Hover,
    pub movement: Movement,
    pub collider: Collider,
    pub transform: Transform,
    pub rotation_driver: RotationDriver,
}

impl YureiBundle {
    pub fn capsule_with_position(position: Vec3) -> Self {
        YureiBundle {
            transform: Transform::from_xyz(position.x, position.y, position.x),
            ..default()
        }
    }
}

impl Default for YureiBundle {
    fn default() -> Self {
        YureiBundle {
            rigidbody: RigidBody::Dynamic,
            velocity: Velocity::default(),
            external_force: ExternalForce::default(),
            external_impulse: ExternalImpulse::default(),
            locked_axes: LockedAxes::ROTATION_LOCKED,
            hover: Hover::default(),
            movement: Movement {
                goal_velocity: Vec3::ZERO,
                direction: Vec3::ZERO,
                acceleration: 125.0,
                deceleration: 10.0,
                top_speed: 125.0,
            },
            rotation_driver: RotationDriver,
            collider: Collider::capsule_y(0.5, 0.5),
            transform: Transform::from_xyz(0.0, 0.0, 0.0),
        }
    }
}