Using PlayerValuesState instead of constants that hold playervalues

src/comps/core/controller.rs

@@ -1,9 +1,9 @@
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::*;
 
-use crate::{logic::core::player::player_movement::{
+use crate::{logic::core::player::{player_movement::{
     move_player, PlayerLinearXZState, PlayerLinearYState, PlayerMovementInput,
-}, ui::game::settings::SettingsScreenUIConfiguration};
+}, player_values_state::PlayerValuesState}, ui::game::settings::SettingsScreenUIConfiguration};
 
 use super::markers::player::Player;
 
@@ -23,6 +23,7 @@ pub fn capture_input(
     >,
     time: Res<Time>,
     settings_screen_config: Res<SettingsScreenUIConfiguration>,
+    player_values_state: Res<PlayerValuesState>
 ) {
     // Don't allocate on each frame. Instead Check if any of the inputs are being pressed and then allocate.
     if keyboard_input.any_pressed([
@@ -50,9 +51,9 @@ pub fn capture_input(
             sprint: keyboard_input.pressed(KeyCode::ShiftLeft),
         };
         if settings_screen_config.settings_menu_shown {
-            move_player(PlayerMovementInput::default(), player_query, time);
+            move_player(PlayerMovementInput::default(), player_query, time, player_values_state);
         } else {
-            move_player(player_movement_input, player_query, time);
+            move_player(player_movement_input, player_query, time, player_values_state);
         }
     }
 }

src/constants/mod.rs

@@ -1 +0,0 @@
-pub mod player_values;

src/constants/player_values.rs

@@ -1,25 +0,0 @@
-pub const MAX_LINEAR_PLAYER_VELOCITY: f32 = 20.0;
-pub const PLAYER_ACCELERATION: f32 = 20.0;
-pub const PLAYER_JUMP_FORCE: f32 = 900.0;
-/// Time in ms that player must be grounded in order to jump again
-pub const PLAYER_JUMP_COOLDOWN_MS: u128 = 75;
-pub const PLAYER_SPRINT_SPEED_MULTIPLIER: f32 = 3.5;
-pub const PLAYER_CROUCH_SPEED_MULTIPLIER: f32 = 0.25;
-pub const PLAYER_INITIAL_WEIGHT: f32 = 75.0;
-pub const PLAYER_GRAVITY_SCALE: f32 = 4.0;
-
-pub const PLAYER_HEIGHT: f32 = 2.5;
-pub const PLAYER_CAMERA_HEIGHT: f32 = 1.25;
-pub const PLAYER_CROUCH_HEIGHT: f32 = 0.0;
-pub const PLAYER_CROUCH_TIME_S: f32 = 1.25;
-
-pub const PLAYER_LINEAR_DAMPING: f32 = 3.5;
-pub const PLAYER_LINEAR_DAMPING_WHILE_JUMPING: f32 = 0.25;
-
-pub const PLAYER_LEAN_TIME: f32 = 0.3;
-pub const PLAYER_LEAN_ANGLE: f32 = 30.0;
-
-pub const PLAYER_LATERAL_ACCELERATION_WHILE_SPRINTING_MULTIPLIER: f32 = 0.2;
-pub const PLAYER_LATERAL_ACCELERATION_MULTIPLIER: f32 = 1.0;
-
-pub const PLAYER_LINEAR_DAMPING_TIME_OFFSET_AFTER_JUMP_IN_MS: u128 = 20;

src/logic/core/player/camera_player_sync.rs

@@ -3,11 +3,10 @@ use bevy::{input::mouse::MouseMotion, prelude::*, window::CursorGrabMode};
 
 use crate::{
     comps::core::markers::{camera::MainCamera, player::Player},
-    constants::player_values::{PLAYER_CAMERA_HEIGHT, PLAYER_CROUCH_HEIGHT, PLAYER_CROUCH_TIME_S, PLAYER_LEAN_TIME, PLAYER_LEAN_ANGLE},
     utils::rad_deg::radians_from_degrees, ui::game::settings::SettingsScreenUIConfiguration,
 };
 
-use super::player_movement::PlayerLinearXZState;
+use super::{player_movement::PlayerLinearXZState, player_values_state::PlayerValuesState};
 
 /// Mouse sensitivity and movement speed
 #[derive(Resource)]
@@ -32,6 +31,7 @@ pub fn update_camera_vertical_position(
     mut player: Query<(&mut Transform, &PlayerLinearXZState), (With<Player>, Without<MainCamera>)>,
     mut camera: Query<&mut Transform, (With<MainCamera>, Without<Player>)>,
     time: Res<Time>,
+    player_values_state: Res<PlayerValuesState>,
 ) {
     let Ok((_, player_linear_xz_state)) = player.get_single_mut() else {
         return;
@@ -46,17 +46,17 @@ pub fn update_camera_vertical_position(
         camera_transform.translation = camera_transform.translation.lerp(
             Vec3 {
                 x: camera_transform.translation.x,
-                y: PLAYER_CROUCH_HEIGHT,
+                y: player_values_state.player_crouch_height,
                 z: camera_transform.translation.z,
             },
-            (delta / PLAYER_CROUCH_TIME_S).clamp(0.0, 1.0),
+            (delta / player_values_state.player_crouch_time_s).clamp(0.0, 1.0),
         );
     } else {
         // TODO: Add elapsed time to standup so that crouch time and standup time is the same.
         camera_transform.translation = camera_transform.translation.lerp(
             Vec3 {
                 x: camera_transform.translation.x,
-                y: PLAYER_CAMERA_HEIGHT,
+                y: player_values_state.player_camera_height,
                 z: camera_transform.translation.z,
             },
             time.delta_seconds().clamp(0.0, 1.0),
@@ -75,6 +75,7 @@ pub fn follow_cursor_with_camera(
     btn: Res<Input<MouseButton>>,
     time: Res<Time>,
     mut settings_screen_config: ResMut<SettingsScreenUIConfiguration>,
+    player_values_state: Res<PlayerValuesState>,
 ) {
     if let Ok(mut window) = primary_window.get_single_mut() {
         if keyboard_input.just_pressed(KeyCode::Escape) {
@@ -130,28 +131,28 @@ pub fn follow_cursor_with_camera(
                     let right = Vec3::new(local_z.z, camera_transform.translation.y, -local_z.x);
                     player_transform.rotation = desired_rotation_quat;
                     if keyboard_input.pressed(KeyCode::Q) {
-                        let final_quat = Quat::from_axis_angle(Vec3::Z, radians_from_degrees(PLAYER_LEAN_ANGLE));
+                        let final_quat = Quat::from_axis_angle(Vec3::Z, radians_from_degrees(player_values_state.player_lean_angle));
                         camera_transform.rotation = camera_transform
                             .rotation
-                            .lerp(final_quat, time.delta_seconds() / PLAYER_LEAN_TIME);
+                            .lerp(final_quat, time.delta_seconds() / player_values_state.player_lean_time);
-                        camera_transform.translation = camera_transform.translation.lerp(Vec3 { x: -right.x, y: camera_transform.translation.y, z: -right.z }, time.delta_seconds() / PLAYER_LEAN_TIME);
+                        camera_transform.translation = camera_transform.translation.lerp(Vec3 { x: -right.x, y: camera_transform.translation.y, z: -right.z }, time.delta_seconds() / player_values_state.player_lean_time);
                     } else if keyboard_input.pressed(KeyCode::E) {
                         let final_quat =
-                            Quat::from_axis_angle(Vec3::Z, radians_from_degrees(-PLAYER_LEAN_ANGLE));
+                            Quat::from_axis_angle(Vec3::Z, radians_from_degrees(-player_values_state.player_lean_angle));
                         camera_transform.rotation = camera_transform
                             .rotation
-                            .lerp(final_quat, time.delta_seconds() / PLAYER_LEAN_TIME);
+                            .lerp(final_quat, time.delta_seconds() / player_values_state.player_lean_time);
-                        camera_transform.translation = camera_transform.translation.lerp(Vec3 { x: right.x, y: camera_transform.translation.y, z: right.z }, time.delta_seconds() / PLAYER_LEAN_TIME);
+                        camera_transform.translation = camera_transform.translation.lerp(Vec3 { x: right.x, y: camera_transform.translation.y, z: right.z }, time.delta_seconds() / player_values_state.player_lean_time);
                     } else {
                         camera_transform.rotation = camera_transform
                             .rotation
-                            .lerp(Quat::default(), time.delta_seconds() / PLAYER_LEAN_TIME);
+                            .lerp(Quat::default(), time.delta_seconds() / player_values_state.player_lean_time);
 
                         camera_transform.translation = camera_transform.translation.lerp(Vec3 {
                             x: 0.0,
                             y: camera_transform.translation.y,
                             z: 0.0,
-                        }, time.delta_seconds() / PLAYER_LEAN_TIME);
+                        }, time.delta_seconds() / player_values_state.player_lean_time);
                     }
                 }
             }

src/logic/core/player/mod.rs

@@ -3,3 +3,4 @@ pub mod camera_player_sync;
 pub mod hands;
 pub mod player_movement;
 pub mod player_vertical_sync;
+pub mod player_values_state;

src/logic/core/player/player_movement.rs

@@ -3,24 +3,20 @@ use bevy_rapier3d::prelude::*;
 
 use crate::{
     comps::core::markers::player::Player,
-    constants::player_values::{
-        MAX_LINEAR_PLAYER_VELOCITY, PLAYER_ACCELERATION, PLAYER_CROUCH_SPEED_MULTIPLIER,
-        PLAYER_JUMP_COOLDOWN_MS, PLAYER_JUMP_FORCE, PLAYER_LATERAL_ACCELERATION_MULTIPLIER,
-        PLAYER_LATERAL_ACCELERATION_WHILE_SPRINTING_MULTIPLIER,
-        PLAYER_LINEAR_DAMPING_WHILE_JUMPING, PLAYER_SPRINT_SPEED_MULTIPLIER,
-    },
 };
 
+use super::player_values_state::PlayerValuesState;
+
 #[derive(Component, Debug)]
 pub enum PlayerLinearYState {
-    Grounded(u128),
+    Grounded(f64),
     Jumping,
     Falling,
 }
 
 #[allow(unused)]
 impl PlayerLinearYState {
-    pub fn is_grounded(&self, longer_than: &u128) -> bool {
+    pub fn is_grounded(&self, longer_than: &f64) -> bool {
         match self {
             Self::Grounded(time_grounded) => time_grounded > longer_than,
             _ => false,
@@ -71,7 +67,7 @@ impl PlayerLinearXZState {
     }
     /*/// If already sprinting, adds time to sprint
     /// If not sprinting sets sprint.
-    pub fn sprint(&mut self, time: u128) {
+    pub fn sprint(&mut self, time: u64) {
         match self {
             PlayerLinearXZState::Sprinting(since) => {},
             _ => *self = PlayerLinearXZState::Sprinting(time)
@@ -115,6 +111,7 @@ pub fn move_player(
         With<Player>,
     >,
     time: Res<Time>,
+    player_values_state: Res<PlayerValuesState>
 ) {
     for (
         mut player_velocity,
@@ -129,13 +126,13 @@ pub fn move_player(
             player_linear_xz_state.toggle_crouch(time.elapsed().as_secs_f32());
         }
         let crouch_multiplier = if player_linear_xz_state.is_crouched() {
-            PLAYER_CROUCH_SPEED_MULTIPLIER
+            player_values_state.player_crouch_speed_multiplier
         } else {
             1.0
         };
         let sprint_multiplier =
             if player_movement_input.sprint && !player_linear_xz_state.is_crouched() {
-                PLAYER_SPRINT_SPEED_MULTIPLIER
+                player_values_state.player_sprint_speed_multiplier
             } else {
                 1.0
             };
@@ -145,9 +142,9 @@ pub fn move_player(
         if !player_linear_y_state.is_jumping() && !player_linear_y_state.is_falling() {
             // Only let player move when grounded
             if player_movement_input.front {
-                if sprint_multiplier == PLAYER_SPRINT_SPEED_MULTIPLIER {
+                if sprint_multiplier == player_values_state.player_sprint_speed_multiplier {
                     *player_linear_xz_state = PlayerLinearXZState::Sprinting;
-                } else if crouch_multiplier == PLAYER_CROUCH_SPEED_MULTIPLIER {
+                } else if crouch_multiplier == player_values_state.player_crouch_speed_multiplier {
                 } else {
                     *player_linear_xz_state = PlayerLinearXZState::Walking;
                 }
@@ -156,10 +153,11 @@ pub fn move_player(
                     player_velocity.linvel,
                     time.delta_seconds(),
                     sprint_multiplier * crouch_multiplier,
+                    player_values_state.player_acceleration
                 );
             }
             if player_movement_input.back {
-                if crouch_multiplier == PLAYER_CROUCH_SPEED_MULTIPLIER {
+                if crouch_multiplier == player_values_state.player_crouch_speed_multiplier {
                 } else {
                     *player_linear_xz_state = PlayerLinearXZState::Walking;
                 }
@@ -168,10 +166,11 @@ pub fn move_player(
                     player_velocity.linvel,
                     time.delta_seconds(),
                     crouch_multiplier,
+                    player_values_state.player_acceleration
                 );
             }
             if player_movement_input.right {
-                if crouch_multiplier == PLAYER_CROUCH_SPEED_MULTIPLIER {
+                if crouch_multiplier == player_values_state.player_crouch_speed_multiplier {
                 } else {
                     *player_linear_xz_state = PlayerLinearXZState::Walking;
                 }
@@ -180,14 +179,15 @@ pub fn move_player(
                     player_velocity.linvel,
                     time.delta_seconds(),
                     if player_linear_xz_state.is_sprinting() {
-                        PLAYER_LATERAL_ACCELERATION_WHILE_SPRINTING_MULTIPLIER * crouch_multiplier
+                        player_values_state.player_lateral_acceleration_while_sprinting_multiplier * crouch_multiplier
                     } else {
-                        PLAYER_LATERAL_ACCELERATION_MULTIPLIER * crouch_multiplier
+                        player_values_state.player_lateral_acceleration_multiplier * crouch_multiplier
                     },
+                    player_values_state.player_acceleration
                 );
             }
             if player_movement_input.left {
-                if crouch_multiplier == PLAYER_CROUCH_SPEED_MULTIPLIER {
+                if crouch_multiplier == player_values_state.player_crouch_speed_multiplier {
                 } else {
                     *player_linear_xz_state = PlayerLinearXZState::Walking;
                 }
@@ -196,42 +196,43 @@ pub fn move_player(
                     player_velocity.linvel,
                     time.delta_seconds(),
                     if player_linear_xz_state.is_sprinting() {
-                        PLAYER_LATERAL_ACCELERATION_WHILE_SPRINTING_MULTIPLIER * crouch_multiplier
+                        player_values_state.player_lateral_acceleration_while_sprinting_multiplier * crouch_multiplier
                     } else {
-                        PLAYER_LATERAL_ACCELERATION_MULTIPLIER * crouch_multiplier
+                        player_values_state.player_lateral_acceleration_multiplier * crouch_multiplier
                     },
+                    player_values_state.player_acceleration
                 );
             }
         }
 
-        if player_movement_input.up && player_linear_y_state.is_grounded(&PLAYER_JUMP_COOLDOWN_MS) {
+        if player_movement_input.up && player_linear_y_state.is_grounded(&player_values_state.player_jump_cooldown_s) {
-            player_external_force.impulse = Vec3::new(0.0, PLAYER_JUMP_FORCE, 0.0);
+            player_external_force.impulse = Vec3::new(0.0, player_values_state.player_jump_force, 0.0);
             *player_linear_y_state = PlayerLinearYState::Jumping;
             *player_damping = Damping {
-                linear_damping: PLAYER_LINEAR_DAMPING_WHILE_JUMPING,
+                linear_damping: player_values_state.player_linear_damping_while_jumping,
                 ..Default::default()
             };
         }
         // When player velocity exceeds max linear velocity then set to max_linear_vel value
         if player_velocity.linvel.x.abs()
-            > MAX_LINEAR_PLAYER_VELOCITY * crouch_multiplier * sprint_multiplier
+            > player_values_state.max_linear_player_velocity * crouch_multiplier * sprint_multiplier
         {
             let positive = player_velocity.linvel.x.is_sign_positive();
             if positive {
                 player_velocity.linvel.x =
-                    MAX_LINEAR_PLAYER_VELOCITY * crouch_multiplier * sprint_multiplier
+                player_values_state.max_linear_player_velocity * crouch_multiplier * sprint_multiplier
             } else {
-                player_velocity.linvel.x = MAX_LINEAR_PLAYER_VELOCITY * -1.0 * crouch_multiplier
+                player_velocity.linvel.x = player_values_state.max_linear_player_velocity * -1.0 * crouch_multiplier
             }
         }
         if player_velocity.linvel.z.abs()
-            > MAX_LINEAR_PLAYER_VELOCITY * crouch_multiplier * sprint_multiplier
+            > player_values_state.max_linear_player_velocity * crouch_multiplier * sprint_multiplier
         {
             let positive = player_velocity.linvel.z.is_sign_positive();
             if positive {
-                player_velocity.linvel.z = MAX_LINEAR_PLAYER_VELOCITY * crouch_multiplier
+                player_velocity.linvel.z = player_values_state.max_linear_player_velocity * crouch_multiplier
             } else {
-                player_velocity.linvel.z = MAX_LINEAR_PLAYER_VELOCITY * -1.0 * crouch_multiplier
+                player_velocity.linvel.z = player_values_state.max_linear_player_velocity * -1.0 * crouch_multiplier
             }
         }
         if player_velocity.linvel.x > -1.0
@@ -251,6 +252,7 @@ fn apply_movement_acceleration_to_vec(
     current_linvel: Vec3,
     delta_time_secs: f32,
     multiplier: f32,
+    player_acceleration: f32,
 ) -> Vec3 {
-    current_linvel + (direction * PLAYER_ACCELERATION * delta_time_secs * multiplier)
+    current_linvel + (direction * player_acceleration * delta_time_secs * multiplier)
 }

src/logic/core/player/player_values_state.rs

@@ -0,0 +1,58 @@
+use bevy::{prelude::{Resource, ReflectResource}, reflect::Reflect};
+
+
+#[derive(Resource, Reflect)]
+#[reflect(Resource)]
+pub struct PlayerValuesState {
+    pub max_linear_player_velocity: f32,
+    pub player_acceleration: f32,
+    pub player_jump_force: f32,
+    
+    pub player_jump_cooldown_s: f64,
+    pub player_sprint_speed_multiplier: f32,
+    pub player_crouch_speed_multiplier: f32,
+    pub player_initial_weight: f32,
+    pub player_gravity_scale: f32,
+
+    pub player_height: f32,
+    pub player_camera_height: f32,
+    pub player_crouch_height: f32,
+    pub player_crouch_time_s: f32,
+    
+    pub player_linear_damping: f32,
+    pub player_linear_damping_while_jumping: f32,
+    
+    pub player_lean_time: f32,
+    pub player_lean_angle: f32,
+
+    pub player_lateral_acceleration_while_sprinting_multiplier: f32,
+    pub player_lateral_acceleration_multiplier: f32,
+
+    pub player_linear_damping_time_offset_after_jump_in_s: f64,
+}
+
+impl Default for PlayerValuesState {
+    fn default() -> Self {
+        Self {
+            max_linear_player_velocity: 20.0,
+            player_acceleration: 20.0,
+            player_jump_force: 900.0,
+            player_jump_cooldown_s: 0.075,
+            player_sprint_speed_multiplier: 3.5,
+            player_crouch_speed_multiplier: 0.25,
+            player_initial_weight: 75.0,
+            player_gravity_scale: 4.0,
+            player_height: 2.5,
+            player_camera_height: 1.25,
+            player_crouch_height: 0.0,
+            player_crouch_time_s: 1.25,
+            player_linear_damping: 3.5,
+            player_linear_damping_while_jumping: 0.25,
+            player_lean_time: 0.3,
+            player_lean_angle: 30.0,
+            player_lateral_acceleration_while_sprinting_multiplier: 0.2,
+            player_lateral_acceleration_multiplier: 1.0,
+            player_linear_damping_time_offset_after_jump_in_s: 0.02,
+        }
+    }
+}

src/logic/core/player/player_vertical_sync.rs

@@ -1,40 +1,35 @@
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::*;
 
-use crate::{
+use crate::comps::core::markers::player::Player;
-    comps::core::markers::player::Player,
-    constants::player_values::{
-        PLAYER_JUMP_COOLDOWN_MS, PLAYER_LINEAR_DAMPING,
-        PLAYER_LINEAR_DAMPING_TIME_OFFSET_AFTER_JUMP_IN_MS, PLAYER_LINEAR_DAMPING_WHILE_JUMPING,
-    },
-};
 
-use super::player_movement::PlayerLinearYState;
+use super::{player_movement::PlayerLinearYState, player_values_state::PlayerValuesState};
 
 /// System that captures linear y velocity and determines whether player is falling or grounded, and how long the player has been grounded for.
 pub fn sync_player_y_state(
     mut query: Query<(&Velocity, &mut PlayerLinearYState, &mut Damping), With<Player>>,
     time: Res<Time>,
+    player_values_state: Res<PlayerValuesState>
 ) {
     for (player_velocity, mut player_linear_y_state, mut player_damping) in &mut query {
         if player_velocity.linvel.y < -1.0 {
             *player_linear_y_state = PlayerLinearYState::Falling;
             *player_damping = Damping {
-                linear_damping: PLAYER_LINEAR_DAMPING_WHILE_JUMPING,
+                linear_damping: player_values_state.player_linear_damping_while_jumping,
                 ..Default::default()
             };
         } else if player_velocity.linvel.y >= -1.0 && player_velocity.linvel.y <= 1.0 {
             let previous_grounded_time = match *player_linear_y_state {
                 PlayerLinearYState::Grounded(grounded_for) => grounded_for,
-                _ => 0,
+                _ => 0.0,
             };
-            let new_grounded_time = previous_grounded_time + time.delta().as_millis();
+            let new_grounded_time = previous_grounded_time + time.delta().as_secs_f64();
             *player_linear_y_state = PlayerLinearYState::Grounded(new_grounded_time);
             if new_grounded_time
-                > PLAYER_JUMP_COOLDOWN_MS - PLAYER_LINEAR_DAMPING_TIME_OFFSET_AFTER_JUMP_IN_MS
+                > player_values_state.player_jump_cooldown_s - player_values_state.player_linear_damping_time_offset_after_jump_in_s
             {
                 *player_damping = Damping {
-                    linear_damping: PLAYER_LINEAR_DAMPING,
+                    linear_damping: player_values_state.player_linear_damping,
                     ..Default::default()
                 };
             }

src/main.rs

@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use bevy_rapier3d::prelude::*;
-use logic::core::guns::player_firing::PlayerFiringInfo;
+use logic::core::{guns::player_firing::PlayerFiringInfo, player::player_values_state::PlayerValuesState};
 use scenes::scene1;
 use ui::game::plugin::MainGameUIPlugin;
 
@@ -29,7 +29,8 @@ fn setup_plugins(application: &mut App) {
         .add_plugins(RapierPhysicsPlugin::<NoUserData>::default())
         .add_plugins(WorldInspectorPlugin::new())
         .add_plugins(MainGameUIPlugin)
-        .register_type::<PlayerFiringInfo>();
+        .register_type::<PlayerFiringInfo>()
+        .register_type::<PlayerValuesState>();
 }
 
 fn load(application: &mut App) {

src/scenes/scene1/init.rs

@@ -7,7 +7,7 @@ use crate::{
                 follow_cursor_with_camera, update_camera_vertical_position, MouseMovementSettings,
             },
             hands::capture_hand_usage,
-            player_vertical_sync::sync_player_y_state,
+            player_vertical_sync::sync_player_y_state, player_values_state::PlayerValuesState,
         }, setup::{assets::load_all_assets, load_state::GameLoadState, spawn::add_all_spawners, animations::{load_animations, AllFirearmAnimations}, equipment::{EquipmentChangeEvent, change_equipment}},
 };
 
@@ -19,6 +19,7 @@ pub fn load_scene(application: &mut App) {
     application.insert_resource(GameLoadState::default());
     application.insert_resource(MouseMovementSettings::default());
     application.insert_resource(AllFirearmAnimations::default());
+    application.insert_resource(PlayerValuesState::default());
     // Startup
     application.add_systems(PreStartup, load_all_assets);
     application.add_systems(Startup, spawn_ground);

src/setup/spawners/player.rs

@@ -6,9 +6,7 @@ use crate::{
         camera::MainCamera,
         player::{Player, PlayerHand, PlayerData},
     },
-    constants::player_values::{
+    logic::core::{player::{player_movement::{PlayerLinearYState, PlayerLinearXZState}, player_values_state::PlayerValuesState}, guns::player_firing::PlayerFiringInfo}, setup::{load_state::GameLoadState, equipment::EquipmentChangeEvent},
-        PLAYER_GRAVITY_SCALE, PLAYER_HEIGHT, PLAYER_INITIAL_WEIGHT, PLAYER_LINEAR_DAMPING,
-    }, logic::core::{player::player_movement::{PlayerLinearYState, PlayerLinearXZState}, guns::player_firing::PlayerFiringInfo}, setup::{load_state::GameLoadState, equipment::EquipmentChangeEvent},
 };
 
 use crate::setup::spawn::SpawnPoint;
@@ -20,6 +18,7 @@ pub fn player_spawner(
     player_sp_query: Query<(Entity, &SpawnPoint<Player>)>,
     mut game_load_state: ResMut<GameLoadState>,
     mut equipment_change_event_writer: EventWriter<EquipmentChangeEvent>,
+    player_values_state: Res<PlayerValuesState>,
 ) {
     if game_load_state.player_loaded || !game_load_state.is_everything_except_player_loaded() {
         return;
@@ -56,8 +55,8 @@ pub fn player_spawner(
             .spawn(Player(PlayerData::default()))
             // Physics
             .insert(RigidBody::Dynamic)
-            .insert(GravityScale(PLAYER_GRAVITY_SCALE))
+            .insert(GravityScale(player_values_state.player_gravity_scale))
-            .insert(Collider::capsule_y(PLAYER_HEIGHT, 2.0))
+            .insert(Collider::capsule_y(player_values_state.player_height, 2.0))
             .insert(Restitution::coefficient(0.0))
             .insert(Friction {
                 coefficient: 0.0,
@@ -69,7 +68,7 @@ pub fn player_spawner(
             })
             .insert(Velocity::zero())
             .insert(Damping {
-                linear_damping: PLAYER_LINEAR_DAMPING,
+                linear_damping: player_values_state.player_linear_damping,
                 angular_damping: 1.0,
             })
             .insert(
@@ -77,7 +76,7 @@ pub fn player_spawner(
                     | LockedAxes::ROTATION_LOCKED_X
                     | LockedAxes::ROTATION_LOCKED_Y,
             )
-            .insert(ColliderMassProperties::Mass(PLAYER_INITIAL_WEIGHT))
+            .insert(ColliderMassProperties::Mass(player_values_state.player_initial_weight))
             .insert(ExternalImpulse {
                 impulse: Vec3::ZERO,
                 torque_impulse: Vec3::ZERO,

src/ui/editor/plugin.rs

@@ -2,6 +2,7 @@ use bevy::prelude::*;
 
 pub struct MainEditorUIPlugin;
 
+#[allow(unused)]
 impl Plugin for MainEditorUIPlugin {
     fn build(&self, app: &mut App) {
         todo!()