497 lines
16 KiB
Rust
497 lines
16 KiB
Rust
use glam::Vec3;
|
|
use kurbo::ParamCurve;
|
|
use rapier3d::math::Vector;
|
|
|
|
use crate::components::player_states::{
|
|
FallingState, IdleState, JumpingState, LeapingState, RollingState, WalkingState,
|
|
};
|
|
use crate::entity::EntityHandle;
|
|
use crate::physics::PhysicsManager;
|
|
use crate::states::state::State;
|
|
use crate::world::World;
|
|
|
|
pub const LEAP_DURATION: f32 = 0.18;
|
|
pub const ROLL_DURATION: f32 = 0.42;
|
|
const LEAP_SPEED: f32 = 18.0;
|
|
const ROLL_SPEED: f32 = 14.0;
|
|
|
|
impl State for IdleState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_enter(&mut self, world: &mut World, entity: EntityHandle)
|
|
{
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let current_velocity = *rigidbody.linvel();
|
|
let idle_damping = world
|
|
.movements
|
|
.with(entity, |m| m.idle_damping)
|
|
.unwrap_or(0.1);
|
|
|
|
let horizontal_velocity = Vec3::new(current_velocity.x, 0.0, current_velocity.z);
|
|
let new_horizontal_velocity = horizontal_velocity * idle_damping;
|
|
|
|
rigidbody.set_linvel(
|
|
Vector::new(
|
|
new_horizontal_velocity.x,
|
|
current_velocity.y,
|
|
new_horizontal_velocity.z,
|
|
),
|
|
true,
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, _delta: f32)
|
|
{
|
|
const GROUND_CHECK_DISTANCE: f32 = 0.6;
|
|
|
|
let current_translation = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
*rigidbody.translation()
|
|
})
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let terrain_height =
|
|
PhysicsManager::get_terrain_height_at(current_translation.x, current_translation.z);
|
|
|
|
if let Some(height) = terrain_height
|
|
{
|
|
let target_y = height + 1.0;
|
|
let distance_to_ground = current_translation.y - target_y;
|
|
|
|
if distance_to_ground.abs() < GROUND_CHECK_DISTANCE
|
|
{
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let next_translation =
|
|
Vector::new(current_translation.x, target_y, current_translation.z);
|
|
rigidbody.set_next_kinematic_translation(next_translation);
|
|
});
|
|
});
|
|
|
|
world.movements.with_mut(entity, |movement| {
|
|
movement.movement_context.is_floored = true;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl State for WalkingState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, delta: f32)
|
|
{
|
|
let (movement_input, walking_config) = world
|
|
.movements
|
|
.with(entity, |movement| {
|
|
let input = world
|
|
.inputs
|
|
.with(entity, |input| input.move_direction)
|
|
.unwrap_or(Vec3::ZERO);
|
|
(input, movement.clone())
|
|
})
|
|
.unwrap();
|
|
|
|
let t = (self.time_in_state / walking_config.walking_acceleration_duration).clamp(0.0, 1.0);
|
|
let acceleration_amount = walking_config.walking_acceleration_curve.eval(t as f64).y as f32;
|
|
|
|
let current_translation = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
*rigidbody.translation()
|
|
})
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let terrain_height =
|
|
PhysicsManager::get_terrain_height_at(current_translation.x, current_translation.z);
|
|
|
|
let target_y = if let Some(height) = terrain_height
|
|
{
|
|
height + 1.0
|
|
}
|
|
else
|
|
{
|
|
current_translation.y
|
|
};
|
|
|
|
let slope_angle = if movement_input.length_squared() > 0.01
|
|
{
|
|
PhysicsManager::get_terrain_slope_in_direction(
|
|
current_translation.x,
|
|
current_translation.z,
|
|
movement_input.x,
|
|
movement_input.z,
|
|
)
|
|
}
|
|
else
|
|
{
|
|
0.0
|
|
};
|
|
|
|
let slope_multiplier = {
|
|
const MAX_SLOPE_ANGLE: f32 = std::f32::consts::PI / 4.0;
|
|
|
|
if slope_angle > 0.0
|
|
{
|
|
let uphill_factor = (slope_angle / MAX_SLOPE_ANGLE).min(1.0);
|
|
1.0 - uphill_factor * 0.9
|
|
}
|
|
else
|
|
{
|
|
let downhill_factor = (slope_angle.abs() / MAX_SLOPE_ANGLE).min(1.0);
|
|
1.0 + downhill_factor * 0.5
|
|
}
|
|
};
|
|
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let current_velocity = *rigidbody.linvel();
|
|
|
|
let horizontal_velocity = Vec3::new(current_velocity.x, 0.0, current_velocity.z);
|
|
|
|
let walking_force = movement_input
|
|
* walking_config.walking_acceleration
|
|
* delta
|
|
* acceleration_amount;
|
|
|
|
let new_horizontal_velocity = (walking_force
|
|
+ horizontal_velocity * walking_config.walking_damping)
|
|
.clamp_length_max(walking_config.max_walking_speed * slope_multiplier);
|
|
|
|
let next_translation = Vector::new(
|
|
current_translation.x + new_horizontal_velocity.x * delta,
|
|
target_y,
|
|
current_translation.z + new_horizontal_velocity.z * delta,
|
|
);
|
|
|
|
rigidbody.set_linvel(
|
|
Vector::new(new_horizontal_velocity.x, 0.0, new_horizontal_velocity.z),
|
|
true,
|
|
);
|
|
rigidbody.set_next_kinematic_translation(next_translation);
|
|
});
|
|
});
|
|
|
|
world.movements.with_mut(entity, |movement| {
|
|
movement.movement_context.is_floored = terrain_height.is_some();
|
|
});
|
|
|
|
if movement_input.length_squared() > 0.1
|
|
{
|
|
world.transforms.with_mut(entity, |transform| {
|
|
let target_rotation = f32::atan2(movement_input.x, movement_input.z);
|
|
transform.rotation.y = target_rotation;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
impl State for JumpingState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_enter(&mut self, world: &mut World, entity: EntityHandle)
|
|
{
|
|
self.time_in_state = 0.0;
|
|
|
|
let current_position = world.transforms.get(entity).unwrap().position;
|
|
|
|
world.jumps.with_mut(entity, |jump| {
|
|
jump.jump_context.in_progress = true;
|
|
jump.jump_context.origin_height = current_position.y;
|
|
jump.jump_context.duration = 0.0;
|
|
jump.jump_context.normal = Vec3::Y;
|
|
});
|
|
}
|
|
|
|
fn on_exit(&mut self, world: &mut World, entity: EntityHandle)
|
|
{
|
|
world.jumps.with_mut(entity, |jump| {
|
|
jump.jump_context.in_progress = false;
|
|
jump.jump_context.duration = 0.0;
|
|
});
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, delta: f32)
|
|
{
|
|
world.jumps.with_mut(entity, |jump| {
|
|
jump.jump_context.duration = self.time_in_state;
|
|
});
|
|
|
|
let jump = world.jumps.with(entity, |jump| jump.clone()).unwrap();
|
|
|
|
let normalized_time = (self.time_in_state / jump.jump_duration).min(1.0);
|
|
let height_progress = jump.jump_curve.eval(normalized_time as f64).y as f32;
|
|
|
|
let origin_height = jump.jump_context.origin_height;
|
|
let target_height = origin_height + height_progress * jump.jump_height;
|
|
|
|
let current_translation = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
*rigidbody.translation()
|
|
})
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let height_diff = target_height - current_translation.y;
|
|
let required_velocity = height_diff / delta;
|
|
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let current_velocity = *rigidbody.linvel();
|
|
let next_translation = Vector::new(
|
|
current_translation.x + current_velocity.x * delta,
|
|
current_translation.y + required_velocity * delta,
|
|
current_translation.z + current_velocity.z * delta,
|
|
);
|
|
|
|
rigidbody.set_linvel(
|
|
Vector::new(current_velocity.x, required_velocity, current_velocity.z),
|
|
true,
|
|
);
|
|
rigidbody.set_next_kinematic_translation(next_translation);
|
|
});
|
|
});
|
|
|
|
world.movements.with_mut(entity, |movement| {
|
|
movement.movement_context.is_floored = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
impl State for FallingState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, delta: f32)
|
|
{
|
|
const GRAVITY: f32 = -9.81 * 5.0;
|
|
const GROUND_CHECK_DISTANCE: f32 = 0.6;
|
|
|
|
let (current_pos, velocity) = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let mut vel = *rigidbody.linvel();
|
|
vel.y += GRAVITY * delta;
|
|
(*rigidbody.translation(), vel)
|
|
})
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let next_pos = current_pos + velocity;
|
|
let terrain_height = PhysicsManager::get_terrain_height_at(next_pos.x, next_pos.z);
|
|
|
|
let is_grounded = if let Some(height) = terrain_height
|
|
{
|
|
let target_y = height + 1.0;
|
|
let distance_to_ground = current_pos.y - target_y;
|
|
|
|
if distance_to_ground < GROUND_CHECK_DISTANCE && velocity.y <= 0.01
|
|
{
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let next_pos = Vector::new(current_pos.x, target_y, current_pos.z);
|
|
rigidbody.set_next_kinematic_translation(next_pos);
|
|
rigidbody.set_linvel(Vector::new(velocity.x, 0.0, velocity.z), true);
|
|
});
|
|
});
|
|
true
|
|
}
|
|
else
|
|
{
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let next_pos = current_pos + velocity * delta;
|
|
rigidbody.set_next_kinematic_translation(next_pos);
|
|
rigidbody.set_linvel(velocity, true);
|
|
});
|
|
});
|
|
false
|
|
}
|
|
}
|
|
else
|
|
{
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
|
|
let next_pos = current_pos + velocity * delta;
|
|
rigidbody.set_next_kinematic_translation(next_pos);
|
|
rigidbody.set_linvel(velocity, true);
|
|
});
|
|
});
|
|
false
|
|
};
|
|
|
|
world.movements.with_mut(entity, |movement| {
|
|
movement.movement_context.is_floored = is_grounded;
|
|
});
|
|
}
|
|
}
|
|
|
|
impl State for LeapingState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_enter(&mut self, world: &mut World, entity: EntityHandle)
|
|
{
|
|
self.time_in_state = 0.0;
|
|
|
|
let facing = world
|
|
.transforms
|
|
.with(entity, |t| {
|
|
let yaw = t.rotation.y;
|
|
Vec3::new(yaw.sin(), 0.0, yaw.cos())
|
|
})
|
|
.unwrap_or(Vec3::Z);
|
|
|
|
let move_dir = world
|
|
.inputs
|
|
.with(entity, |i| i.move_direction)
|
|
.unwrap_or(Vec3::ZERO);
|
|
|
|
self.leap_direction = if move_dir.length_squared() > 0.01
|
|
{
|
|
move_dir
|
|
}
|
|
else
|
|
{
|
|
facing
|
|
};
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, delta: f32)
|
|
{
|
|
let current_translation = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rb| *rb.translation())
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let terrain_height =
|
|
PhysicsManager::get_terrain_height_at(current_translation.x, current_translation.z);
|
|
let target_y = terrain_height
|
|
.map(|h| h + 1.0)
|
|
.unwrap_or(current_translation.y);
|
|
|
|
let velocity = self.leap_direction * LEAP_SPEED;
|
|
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rb| {
|
|
let next = Vector::new(
|
|
current_translation.x + velocity.x * delta,
|
|
target_y,
|
|
current_translation.z + velocity.z * delta,
|
|
);
|
|
rb.set_linvel(Vector::new(velocity.x, 0.0, velocity.z), true);
|
|
rb.set_next_kinematic_translation(next);
|
|
});
|
|
});
|
|
|
|
world.movements.with_mut(entity, |m| {
|
|
m.movement_context.is_floored = terrain_height.is_some();
|
|
});
|
|
|
|
world.transforms.with_mut(entity, |t| {
|
|
t.rotation.y = f32::atan2(self.leap_direction.x, self.leap_direction.z);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl State for RollingState
|
|
{
|
|
fn tick_time(&mut self, delta: f32)
|
|
{
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn on_enter(&mut self, world: &mut World, entity: EntityHandle)
|
|
{
|
|
self.time_in_state = 0.0;
|
|
|
|
self.roll_direction = world
|
|
.inputs
|
|
.with(entity, |i| i.move_direction)
|
|
.filter(|d| d.length_squared() > 0.01)
|
|
.unwrap_or_else(|| {
|
|
world
|
|
.transforms
|
|
.with(entity, |t| {
|
|
let yaw = t.rotation.y;
|
|
Vec3::new(yaw.sin(), 0.0, yaw.cos())
|
|
})
|
|
.unwrap_or(Vec3::Z)
|
|
});
|
|
}
|
|
|
|
fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, delta: f32)
|
|
{
|
|
let t = (self.time_in_state / ROLL_DURATION).clamp(0.0, 1.0);
|
|
let speed = ROLL_SPEED * (1.0 - t * 0.6);
|
|
|
|
let current_translation = world
|
|
.physics
|
|
.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rb| *rb.translation())
|
|
})
|
|
.flatten()
|
|
.unwrap();
|
|
|
|
let terrain_height =
|
|
PhysicsManager::get_terrain_height_at(current_translation.x, current_translation.z);
|
|
let target_y = terrain_height
|
|
.map(|h| h + 1.0)
|
|
.unwrap_or(current_translation.y);
|
|
|
|
let velocity = self.roll_direction * speed;
|
|
|
|
world.physics.with(entity, |physics| {
|
|
PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rb| {
|
|
let next = Vector::new(
|
|
current_translation.x + velocity.x * delta,
|
|
target_y,
|
|
current_translation.z + velocity.z * delta,
|
|
);
|
|
rb.set_linvel(Vector::new(velocity.x, 0.0, velocity.z), true);
|
|
rb.set_next_kinematic_translation(next);
|
|
});
|
|
});
|
|
|
|
world.movements.with_mut(entity, |m| {
|
|
m.movement_context.is_floored = terrain_height.is_some();
|
|
});
|
|
}
|
|
}
|