MAJOR rendering overhaul. Snow deformation, persistent light, flowmap out. Also ECS architexture overhaul

src/systems/player_states.rs

@@ -0,0 +1,415 @@
+use glam::Vec3;
+use kurbo::ParamCurve;
+use rapier3d::math::Vector;
+
+use crate::entity::EntityHandle;
+use crate::physics::PhysicsManager;
+use crate::state::State;
+use crate::utility::time::Time;
+use crate::world::World;
+
+pub struct PlayerFallingState
+{
+    pub entity: EntityHandle,
+}
+
+impl State for PlayerFallingState
+{
+    fn get_state_name(&self) -> &'static str
+    {
+        "PlayerFallingState"
+    }
+
+    fn on_state_enter(&mut self, _world: &mut World)
+    {
+        println!("entered falling");
+    }
+
+    fn on_state_exit(&mut self, _world: &mut World) {}
+
+    fn on_state_update(&mut self, _world: &mut World, _delta: f32) {}
+
+    fn on_state_physics_update(&mut self, world: &mut World, delta: f32)
+    {
+        const GRAVITY: f32 = -9.81 * 5.0;
+        const GROUND_CHECK_DISTANCE: f32 = 0.6;
+
+        let (current_pos, velocity) = world
+            .physics
+            .with(self.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(self.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(self.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(self.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(self.entity, |movement| {
+            movement.movement_config.movement_context.is_floored = is_grounded;
+        });
+    }
+}
+
+pub struct PlayerIdleState
+{
+    pub entity: EntityHandle,
+}
+
+impl State for PlayerIdleState
+{
+    fn get_state_name(&self) -> &'static str
+    {
+        "PlayerIdleState"
+    }
+
+    fn on_state_enter(&mut self, world: &mut World)
+    {
+        println!("entered idle");
+
+        world.physics.with(self.entity, |physics| {
+            PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
+                let current_velocity = *rigidbody.linvel();
+                let idle_damping = world
+                    .movements
+                    .with(self.entity, |m| m.movement_config.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_state_exit(&mut self, _world: &mut World) {}
+
+    fn on_state_update(&mut self, _world: &mut World, _delta: f32) {}
+
+    fn on_state_physics_update(&mut self, world: &mut World, _delta: f32)
+    {
+        const GROUND_CHECK_DISTANCE: f32 = 0.6;
+
+        let current_translation = world
+            .physics
+            .with(self.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(self.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(self.entity, |movement| {
+                    movement.movement_config.movement_context.is_floored = true;
+                });
+            }
+        }
+    }
+}
+
+pub struct PlayerWalkingState
+{
+    pub entity: EntityHandle,
+    pub enter_time_stamp: f32,
+}
+
+impl State for PlayerWalkingState
+{
+    fn get_state_name(&self) -> &'static str
+    {
+        "PlayerWalkingState"
+    }
+
+    fn on_state_enter(&mut self, _world: &mut World)
+    {
+        self.enter_time_stamp = Time::get_time_elapsed();
+        println!("entered walking");
+    }
+
+    fn on_state_exit(&mut self, _world: &mut World) {}
+
+    fn on_state_update(&mut self, _world: &mut World, _delta: f32) {}
+
+    fn on_state_physics_update(&mut self, world: &mut World, delta: f32)
+    {
+        let (movement_input, walking_config) = world
+            .movements
+            .with(self.entity, |movement| {
+                let input = world
+                    .inputs
+                    .with(self.entity, |input| input.move_direction)
+                    .unwrap_or(Vec3::ZERO);
+                (input, movement.movement_config.clone())
+            })
+            .unwrap();
+
+        let current_time = Time::get_time_elapsed();
+        let elapsed_time = current_time - self.enter_time_stamp;
+
+        let t = (elapsed_time / 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(self.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(self.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(self.entity, |movement| {
+            movement.movement_config.movement_context.is_floored = terrain_height.is_some();
+        });
+
+        if movement_input.length_squared() > 0.1
+        {
+            world.transforms.with_mut(self.entity, |transform| {
+                let target_rotation = f32::atan2(movement_input.x, movement_input.z);
+                transform.rotation.y = target_rotation;
+            });
+        }
+    }
+}
+
+pub struct PlayerJumpingState
+{
+    pub entity: EntityHandle,
+    pub enter_time_stamp: f32,
+}
+
+impl State for PlayerJumpingState
+{
+    fn get_state_name(&self) -> &'static str
+    {
+        "PlayerJumpingState"
+    }
+
+    fn on_state_enter(&mut self, world: &mut World)
+    {
+        self.enter_time_stamp = Time::get_time_elapsed();
+
+        let current_position = world.transforms.get(self.entity).unwrap().position;
+
+        world.jumps.with_mut(self.entity, |jump| {
+            jump.jump_config.jump_context.in_progress = true;
+            jump.jump_config.jump_context.execution_time = self.enter_time_stamp;
+            jump.jump_config.jump_context.origin_height = current_position.y;
+            jump.jump_config.jump_context.duration = 0.0;
+            jump.jump_config.jump_context.normal = Vec3::Y;
+        });
+
+        println!("entered jumping");
+    }
+
+    fn on_state_exit(&mut self, world: &mut World)
+    {
+        world.jumps.with_mut(self.entity, |jump| {
+            jump.jump_config.jump_context.in_progress = false;
+            jump.jump_config.jump_context.duration = 0.0;
+        });
+
+        println!("exited jumping");
+    }
+
+    fn on_state_update(&mut self, _world: &mut World, _delta: f32) {}
+
+    fn on_state_physics_update(&mut self, world: &mut World, delta: f32)
+    {
+        let current_time = Time::get_time_elapsed();
+
+        world.jumps.with_mut(self.entity, |jump| {
+            jump.jump_config.jump_context.duration =
+                current_time - jump.jump_config.jump_context.execution_time;
+        });
+
+        let jump_config = world
+            .jumps
+            .with_mut(self.entity, |jump| jump.jump_config.clone())
+            .unwrap();
+
+        let elapsed_time = jump_config.jump_context.duration;
+        let normalized_time = (elapsed_time / jump_config.jump_duration).min(1.0);
+        let height_progress = jump_config.jump_curve.eval(normalized_time as f64).y as f32;
+
+        let origin_height = jump_config.jump_context.origin_height;
+        let target_height = origin_height + height_progress * jump_config.jump_height;
+
+        let current_translation = world
+            .physics
+            .with(self.entity, |physics| {
+                PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
+                    *rigidbody.translation()
+                })
+            })
+            .flatten()
+            .unwrap();
+
+        let current_y = current_translation.y;
+        let height_diff = target_height - current_y;
+        let required_velocity = height_diff / delta;
+
+        world.physics.with(self.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(self.entity, |movement| {
+            movement.movement_config.movement_context.is_floored = false;
+        });
+    }
+}