franklinblanco
/
experiment
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modular animation system, spawnpoints, weapons, equipment events.

This commit is contained in:
Franklin Blanco 2023-09-18 14:18:55 -07:00
parent 57587d1586
commit af2e23b275
18 changed files with 228 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/comps/core/markers/firearm.rs
View File

@ -2,8 +2,8 @@ use bevy::prelude::{Component, Quat, Vec3};
use crate::logic::core::guns::{caliber::Caliber, spray_pattern::FirearmSprayPattern};
#[derive(Component)]
pub struct FirearmData<'a> {
#[derive(Component, Clone)]
pub struct FirearmData {
/// Where the bullets will come out of, and muzzle flash will be spawned out of.
pub firing_point: Vec3,
pub caliber: Caliber,
@ -14,9 +14,8 @@ pub struct FirearmData<'a> {
/// Amount of seconds it takes for gun to come down from shooting
/// Also is the time it takes for the gun to aim in or aim out.
pub rebound_time_seconds: f32,
pub asset_path: &'a str,
pub identifier: String,
pub asset_path: String,
pub vertical_recoil_modifier: f32,
pub horizontal_recoil_modifier: f32,

8
src/comps/core/markers/player.rs
View File

@ -1,7 +1,13 @@
use bevy::prelude::Component;
use crate::setup::equipment::Equipment;
#[derive(Clone, Default)]
pub struct PlayerData {
pub equipment: Equipment,
}
#[derive(Component)]
pub struct Player;
pub struct Player(pub PlayerData);
#[derive(Component)]
pub struct PlayerHand;

4
src/constants/player_values.rs
View File

@ -1,5 +1,3 @@
use crate::logic::core::guns::firearm::Firearm;
pub const MAX_LINEAR_PLAYER_VELOCITY: f32 = 20.0;
pub const PLAYER_ACCELERATION: f32 = 20.0;
pub const PLAYER_JUMP_FORCE: f32 = 900.0;
@ -25,5 +23,3 @@ 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;
pub const DEFAULT_PLAYER_FIREARM: Firearm = Firearm::M4A1;

1
src/logic/core/guns/caliber.rs
View File

@ -1,4 +1,5 @@
#[allow(unused)]
#[derive(Clone)]
pub enum Caliber {
NATO556,
}

9
src/logic/core/guns/equip_firearm.rs
View File

@ -1,7 +1,4 @@
use bevy::prelude::*;
#[allow(unused)]
/// System that checks if player
pub fn equip_firearm() {
}
#[derive(Event)]
pub struct SpawnFirearmEvent();

4
src/logic/core/guns/firearm.rs
View File

@ -26,7 +26,6 @@ impl Firearm {
1.0, 1.2, 1.3, -1.6, 1.5, -1.7, -1.5, 1.5, -1.5, 2.0 // 10 for now
]),
},
asset_path: "weapons/m4a1_rifle.glb",
final_aimed_rotation: Quat::from_rotation_x(0.026),
final_rotation: Quat::default(),
@ -43,8 +42,7 @@ impl Firearm {
y: -0.45,
z: -2.7,
},
identifier: String::from("m4a1_rifle"),
asset_path: String::from("weapons/m4a1_rifle.glb"),
}
}
pub fn holdable_object_data(&self) -> HoldableObjectData {

1
src/logic/core/guns/mod.rs
View File

@ -1,6 +1,5 @@
pub mod caliber;
pub mod firearm;
pub mod player_firing;
pub mod spawn_firearm;
pub mod spray_pattern;
pub mod equip_firearm;

4
src/logic/core/guns/player_firing.rs
View File

@ -2,8 +2,8 @@ use std::time::Duration;
use bevy::prelude::*;
#[derive(Resource, Reflect)]
#[reflect(Resource)]
#[derive(Component, Reflect)]
#[reflect(Component)]
pub struct PlayerFiringInfo {
/// Timestamp since last round fired from the gun. (seconds)
pub last_shot_timestamp: f32,

58
src/logic/core/guns/spawn_firearm.rs
View File

@ -1,58 +0,0 @@
use std::time::Duration;
use bevy::{prelude::*, gltf::Gltf};
use crate::{
comps::core::markers::{holdable::InPlayerHands, player::PlayerHand, firearm::{MagazineData, FirearmData}},
constants::player_values::DEFAULT_PLAYER_FIREARM,
utils, setup::{animations::FirearmAnimations, assets::{GltfAssets, GltfAssetType}},
};
use super::{player_firing::PlayerFiringInfo, firearm::Firearm};
pub fn spawn_firearm_on_player_hands(
mut commands: Commands,
query: Query<Entity, With<PlayerHand>>,
mut player_firing_info: ResMut<PlayerFiringInfo>,
assets_gltf: Res<GltfAssets>,
loaded_gltf_assets: Res<Assets<Gltf>>,
) {
if let Some(asset_handle) = assets_gltf.assets.iter().find(|asset| asset.asset_type == GltfAssetType::Firearm(Firearm::M4A1)) {
if let Some(gltf) = loaded_gltf_assets.get(&asset_handle.asset) {
for entity in query.iter() {
let mut firearm_transform = Transform::from_xyz(0.0, 0.0, 0.0);
firearm_transform.rotate_y(utils::rad_deg::radians_from_degrees(
DEFAULT_PLAYER_FIREARM.holdable_object_data().y_rot,
));
let scene = gltf.scenes[0].clone();
let firearm = commands
.spawn((
SceneBundle {
scene,
visibility: Visibility::Inherited,
transform: firearm_transform,
..default()
},
DEFAULT_PLAYER_FIREARM.firearm_data(),
DEFAULT_PLAYER_FIREARM.holdable_object_data(),
MagazineData { rounds_shot: 0, max_capacity: DEFAULT_PLAYER_FIREARM.firearm_data().max_capacity },
InPlayerHands,
))
.id();
commands.entity(entity).push_children(&[firearm]);
let time_in_secs_between_each_round =
1.0 / DEFAULT_PLAYER_FIREARM.firearm_data().fire_rate * 60.0;
player_firing_info.full_auto_timer = Timer::new(
Duration::from_secs_f32(time_in_secs_between_each_round),
TimerMode::Once,
);
// Load animations
//commands.insert_resource(FirearmAnimations { reload_magazine: asset_server.load(format!("{}#Animation0", DEFAULT_PLAYER_FIREARM.firearm_data().asset_path))})
}
}
}
}

1
src/logic/core/guns/spray_pattern.rs
View File

@ -1,5 +1,6 @@
#[derive(Clone)]
pub struct FirearmSprayPattern {
pub vertical: Vec<f32>,
pub horizontal: Vec<f32>,

174
src/logic/core/player/hands.rs
View File

@ -1,8 +1,8 @@
use bevy::prelude::*;
use crate::{
comps::core::markers::{firearm::{FirearmData, MagazineData}, holdable::InPlayerHands, player::PlayerHand},
logic::core::guns::player_firing::PlayerFiringInfo, utils::rad_deg::radians_from_degrees, setup::animations::FirearmAnimations,
comps::core::markers::{firearm::{FirearmData, MagazineData}, holdable::InPlayerHands, player::{PlayerHand, Player}},
logic::core::guns::player_firing::PlayerFiringInfo, utils::rad_deg::radians_from_degrees, setup::{animations::AllFirearmAnimations, load_state::GameLoadState},
};
pub fn capture_hand_usage(
@ -11,99 +11,113 @@ pub fn capture_hand_usage(
mut hand_query: Query<&mut Transform, With<PlayerHand>>,
time: Res<Time>,
mut player_firing_info: ResMut<PlayerFiringInfo>,
mut firearm_query: Query<
(&mut Transform, &'static FirearmData, &mut MagazineData),
(With<InPlayerHands>, Without<PlayerHand>),
>,
player_query: Query<&Player>,
mut player_firing_info_query: Query<&mut PlayerFiringInfo, With<Player>>,
all_firearm_animations: Res<AllFirearmAnimations>,
mut animation_players: Query<&mut AnimationPlayer>,
animation_clips: Res<Assets<AnimationClip>>,
mut players: Query<&mut AnimationPlayer>,
game_load_state: Res<GameLoadState>,
) {
player_firing_info.full_auto_timer.tick(time.delta());
if !game_load_state.player_loaded {
return;
}
if let Some(player_firearm) = player_query.single().0.equipment.primary_firearm.clone() {
for mut player_firing_info in player_firing_info_query.iter_mut() {
player_firing_info.full_auto_timer.tick(time.delta());
for (mut _firearm_transform, firearm_data, mut magazine_data) in firearm_query.iter_mut() {
for mut hand_transform in hand_query.iter_mut() {
for (mut _firearm_transform, firearm_data, mut magazine_data) in firearm_query.iter_mut() {
for mut hand_transform in hand_query.iter_mut() {
if player_firing_info.is_reloading {
for player in &mut players {
/*if let Some(reload_animation) = animation_clips.get(&animations.reload_magazine) {
if player.elapsed() >= reload_animation.duration() {
magazine_data.rounds_shot = 0;
player_firing_info.is_reloading = false;
if player_firing_info.is_reloading {
for animation_player in &mut animation_players {
if let Some(firearm_animations) = all_firearm_animations.animations.iter().find(|animation| &animation.firearm == &player_firearm) {
if let Some(animation_clip) = animation_clips.get(&firearm_animations.reload_magazine) {
if animation_player.elapsed() >= animation_clip.duration() {
magazine_data.rounds_shot = 0;
player_firing_info.is_reloading = false;
}
}
}
}
}*/
}
} else { // Player is not in a reload animation
if keyboard_input.just_pressed(KeyCode::R) {
// Start reload animation
/*for mut player in &mut players {
player.start(animations.reload_magazine.clone_weak());
player_firing_info.is_reloading = true;
}*/
// Set is_reloading = true
// At the end of reload animation, set magazine data to capacity = 0
}
// AIMING IN/OUT
if mouse_buttons.pressed(MouseButton::Right) {
let rotation_lerp_quat = hand_transform.rotation.lerp(
firearm_data.final_aimed_rotation,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
let position_lerp_vec3 = hand_transform.translation.lerp(
firearm_data.final_aimed_position,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
hand_transform.rotation = rotation_lerp_quat;
hand_transform.translation = position_lerp_vec3;
} else {
hand_transform.rotation = hand_transform
.rotation
.lerp(firearm_data.final_rotation, (time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0));
hand_transform.translation = hand_transform.translation.lerp(
firearm_data.final_position,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
}
// SHOOTING & RECOIL
if mouse_buttons.pressed(MouseButton::Left) {
if player_firing_info.full_auto_timer.finished() {
if magazine_data.rounds_shot < magazine_data.max_capacity {
// Get recoil numbers from patterns
let vertical_recoil_number: f32 = match firearm_data.recoil_pattern.vertical.get(player_firing_info.current_round_index) {
Some(vert_recoil_number) => *vert_recoil_number,
None => {
*firearm_data.recoil_pattern.vertical.last().expect("FOUND A FIREARM_DATA WITHOUT ANY FIREARM_RECOIL_PATTERN.")
},
};
let horizontal_recoil_number: f32 = match firearm_data.recoil_pattern.horizontal.get(player_firing_info.current_round_index) {
Some(horizontal_recoil_number) => *horizontal_recoil_number,
None => {
*firearm_data.recoil_pattern.horizontal.last().expect("FOUND A FIREARM_DATA WITHOUT ANY FIREARM_RECOIL_PATTERN.")
},
};
// Increment indexes and timers
player_firing_info.current_round_index += 1;
player_firing_info.last_shot_timestamp = time.elapsed_seconds();
player_firing_info.full_auto_timer.reset();
magazine_data.rounds_shot += 1;
} else { // Player is not in a reload animation
if keyboard_input.just_pressed(KeyCode::R) {
// Start reload animation
for mut animation_player in &mut animation_players {
if let Some(firearm_animations) = all_firearm_animations.animations.iter().find(|animation| &animation.firearm == &player_firearm) {
animation_player.start(firearm_animations.reload_magazine.clone_weak());
player_firing_info.is_reloading = true;
}
}
// Set is_reloading = true
// At the end of reload animation, set magazine data to capacity = 0
}
// AIMING IN/OUT
if mouse_buttons.pressed(MouseButton::Right) {
let rotation_lerp_quat = hand_transform.rotation.lerp(
firearm_data.final_aimed_rotation,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
let position_lerp_vec3 = hand_transform.translation.lerp(
firearm_data.final_aimed_position,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
hand_transform.rotation = rotation_lerp_quat;
hand_transform.translation = position_lerp_vec3;
} else {
hand_transform.rotation = hand_transform
.rotation
.lerp(firearm_data.final_rotation, (time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0));
hand_transform.translation = hand_transform.translation.lerp(
firearm_data.final_position,
(time.delta_seconds() / firearm_data.rebound_time_seconds).clamp(0.0, 1.0),
);
}
// SHOOTING & RECOIL
if mouse_buttons.pressed(MouseButton::Left) {
if player_firing_info.full_auto_timer.finished() {
if magazine_data.rounds_shot < magazine_data.max_capacity {
// Get recoil numbers from patterns
let vertical_recoil_number: f32 = match firearm_data.recoil_pattern.vertical.get(player_firing_info.current_round_index) {
Some(vert_recoil_number) => *vert_recoil_number,
None => {
*firearm_data.recoil_pattern.vertical.last().expect("FOUND A FIREARM_DATA WITHOUT ANY FIREARM_RECOIL_PATTERN.")
},
};
let horizontal_recoil_number: f32 = match firearm_data.recoil_pattern.horizontal.get(player_firing_info.current_round_index) {
Some(horizontal_recoil_number) => *horizontal_recoil_number,
None => {
*firearm_data.recoil_pattern.horizontal.last().expect("FOUND A FIREARM_DATA WITHOUT ANY FIREARM_RECOIL_PATTERN.")
},
};
// Increment indexes and timers
player_firing_info.current_round_index += 1;
player_firing_info.last_shot_timestamp = time.elapsed_seconds();
player_firing_info.full_auto_timer.reset();
magazine_data.rounds_shot += 1;
// Apply recoil
hand_transform
.rotate_x(radians_from_degrees(firearm_data.vertical_recoil_modifier * vertical_recoil_number));
hand_transform.rotate_y(radians_from_degrees(firearm_data.horizontal_recoil_modifier * horizontal_recoil_number));
// Apply recoil
hand_transform
.rotate_x(radians_from_degrees(firearm_data.vertical_recoil_modifier * vertical_recoil_number));
hand_transform.rotate_y(radians_from_degrees(firearm_data.horizontal_recoil_modifier * horizontal_recoil_number));
} else {
//TODO: play magazine empty sound
}
}
} else {
//TODO: play magazine empty sound
if player_firing_info.full_auto_timer.finished() {
player_firing_info.current_round_index = 0;
}
}
}
} else {
if player_firing_info.full_auto_timer.finished() {
player_firing_info.current_round_index = 0;
}
}
}
}
}

4
src/main.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin}};
use bevy_inspector_egui::quick::WorldInspectorPlugin;
use bevy_rapier3d::prelude::*;
use logic::core::guns::player_firing::PlayerFiringInfo;
@ -26,6 +26,8 @@ fn setup_plugins(application: &mut App) {
.add_plugins(DefaultPlugins)
.add_plugins(RapierPhysicsPlugin::<NoUserData>::default())
.add_plugins(WorldInspectorPlugin::new())
.add_plugins(LogDiagnosticsPlugin::default())
.add_plugins(FrameTimeDiagnosticsPlugin::default())
.register_type::<PlayerFiringInfo>();
}

18
src/scenes/scene1/init.rs
View File

@ -2,16 +2,13 @@ use bevy::prelude::*;
use crate::{
comps::core::controller::capture_input,
logic::core::{
guns::{player_firing::PlayerFiringInfo, spawn_firearm::spawn_firearm_on_player_hands},
player::{
logic::core::player::{
camera_player_sync::{
follow_cursor_with_camera, update_camera_vertical_position, MouseMovementSettings,
},
hands::capture_hand_usage,
player_vertical_sync::sync_player_y_state,
},
}, setup::{assets::load_all_assets, load_state::GameLoadState, spawn::add_all_spawners, animations::load_animations},
}, setup::{assets::load_all_assets, load_state::GameLoadState, spawn::add_all_spawners, animations::{load_animations, AllFirearmAnimations}, equipment::{EquipmentChangeEvent, change_equipment}},
};
use super::{
@ -21,18 +18,13 @@ use super::{
pub fn load_scene(application: &mut App) {
application.insert_resource(GameLoadState::default());
application.insert_resource(MouseMovementSettings::default());
application.insert_resource(PlayerFiringInfo::default());
application.insert_resource(AllFirearmAnimations::default());
// Startup
application.add_systems(PreStartup, load_all_assets);
application.add_systems(Startup, spawn_ground);
application.add_systems(Startup, spawn_obstacles);
application.add_systems(Startup, setup_lighting);
application.add_systems(Startup, set_spawn_points);
application.add_systems(
PostStartup,
spawn_firearm_on_player_hands,
);
// Update
add_all_spawners(application);
application.add_systems(Update, capture_input);
@ -44,4 +36,8 @@ pub fn load_scene(application: &mut App) {
application.add_systems(Update, set_skybox_if_loaded);
application.add_systems(Update, update_camera_vertical_position);
application.add_systems(Update, capture_hand_usage);
application.add_systems(Update, change_equipment);
application.add_event::<EquipmentChangeEvent>();
}

4
src/scenes/scene1/spawn_points.rs
View File

@ -1,8 +1,8 @@
use bevy::prelude::*;
use crate::{setup::spawn::SpawnPoint, comps::core::markers::player::Player};
use crate::{setup::{spawn::SpawnPoint, equipment::Equipment}, comps::core::markers::player::{Player, PlayerData}, logic::core::guns::firearm::Firearm};
pub fn set_spawn_points(mut commands: Commands) {
commands.spawn(SpawnPoint { at: Transform::from_xyz(3.0, 5.0, 2.0), what: Player });
commands.spawn(SpawnPoint { at: Transform::from_xyz(3.0, 5.0, 2.0), what: Player(PlayerData{ equipment: Equipment { primary_firearm: Some(Firearm::M4A1) }}) });
}

2
src/setup/animations.rs
View File

@ -4,7 +4,7 @@ use crate::logic::core::guns::firearm::Firearm;
use super::{assets::GltfAssets, load_state::GameLoadState};
#[derive(Resource)]
#[derive(Resource, Default)]
pub struct AllFirearmAnimations {
pub animations: Vec<FirearmAnimations>,
}

91
src/setup/equipment.rs Normal file
View File

@ -0,0 +1,91 @@
use std::time::Duration;
use bevy::{prelude::*, gltf::Gltf};
use crate::{logic::core::guns::{firearm::Firearm, player_firing::PlayerFiringInfo}, comps::core::markers::{player::{Player, PlayerHand}, firearm::{MagazineData, FirearmData}, holdable::InPlayerHands}, utils};
use super::assets::{GltfAssets, GltfAssetType};
#[derive(Event)]
pub struct EquipmentChangeEvent(pub Equipment);
/// Foundation for inventory System.
#[derive(Component, Clone, Default)]
pub struct Equipment {
pub primary_firearm: Option<Firearm>,
}
/// Called whenever player wants to change equipment
pub fn change_equipment(
mut commands: Commands,
mut equipment_change_event_reader: EventReader<EquipmentChangeEvent>,
mut player_query: Query<(&mut Player, &mut PlayerFiringInfo)>,
mut player_hands_query: Query<Entity, With<PlayerHand>>,
assets_gltf: Res<GltfAssets>,
loaded_gltf_assets: Res<Assets<Gltf>>,
) {
for equipment_change_event in equipment_change_event_reader.iter() {
// TODO: Equipment change
let (mut player, player_firing_info) = player_query.single_mut() ;
// Primary firearm change
if equipment_change_event.0.primary_firearm != player.0.equipment.primary_firearm {
let player_hands = player_hands_query.single_mut();
commands.entity(player_hands).clear_children(); // Don't do this without keeping the state from the last mag
if let Some(new_firearm) = equipment_change_event.0.primary_firearm.clone() {
spawn_firearm_on_player_hands(&mut commands, player_firing_info, player_hands, &assets_gltf, &loaded_gltf_assets, new_firearm);
}
// Set the player's equipment to the newly spawned equipment
player.0.equipment.primary_firearm = equipment_change_event.0.primary_firearm.clone();
}
}
}
fn spawn_firearm_on_player_hands(
commands: &mut Commands,
mut player_firing_info: Mut<PlayerFiringInfo>,
player_hands: Entity,
assets_gltf: &GltfAssets,
loaded_gltf_assets: &Assets<Gltf>,
firearm: Firearm,
) {
if let Some(asset_handle) = assets_gltf.assets.iter().find(|asset| asset.asset_type == GltfAssetType::Firearm(firearm.clone())) {
if let Some(gltf) = loaded_gltf_assets.get(&asset_handle.asset) {
let mut firearm_transform = Transform::from_xyz(0.0, 0.0, 0.0);
firearm_transform.rotate_y(utils::rad_deg::radians_from_degrees(
firearm.holdable_object_data().y_rot,
));
let scene = gltf.scenes[0].clone();
let firearm_data: FirearmData = firearm.firearm_data();
let firearm_entity = commands
.spawn((
SceneBundle {
scene,
visibility: Visibility::Inherited,
transform: firearm_transform,
..default()
},
firearm_data.clone(),
firearm.holdable_object_data(),
MagazineData { rounds_shot: 0, max_capacity: firearm_data.max_capacity },
InPlayerHands,
))
.id();
commands.entity(player_hands).push_children(&[firearm_entity]);
let time_in_secs_between_each_round =
1.0 / firearm_data.fire_rate * 60.0;
player_firing_info.full_auto_timer = Timer::new(
Duration::from_secs_f32(time_in_secs_between_each_round),
TimerMode::Once,
);
}
}
}

3
src/setup/mod.rs
View File

@ -2,4 +2,5 @@ pub mod assets;
pub mod animations;
pub mod load_state;
pub mod spawn;
pub mod spawners;
pub mod spawners;
pub mod equipment;

14
src/setup/spawners/player.rs
View File

@ -4,11 +4,11 @@ use bevy_rapier3d::prelude::*;
use crate::{
comps::core::markers::{
camera::MainCamera,
player::{Player, PlayerHand},
player::{Player, PlayerHand, PlayerData},
},
constants::player_values::{
PLAYER_GRAVITY_SCALE, PLAYER_HEIGHT, PLAYER_INITIAL_WEIGHT, PLAYER_LINEAR_DAMPING,
}, logic::core::player::player_movement::{PlayerLinearYState, PlayerLinearXZState}, setup::load_state::GameLoadState,
}, logic::core::{player::player_movement::{PlayerLinearYState, PlayerLinearXZState}, guns::player_firing::PlayerFiringInfo}, setup::{load_state::GameLoadState, equipment::EquipmentChangeEvent},
};
use crate::setup::spawn::SpawnPoint;
@ -19,6 +19,7 @@ pub fn player_spawner(
mut commands: Commands,
player_sp_query: Query<(Entity, &SpawnPoint<Player>)>,
mut game_load_state: ResMut<GameLoadState>,
mut equipment_change_event_writer: EventWriter<EquipmentChangeEvent>,
) {
if game_load_state.player_loaded || !game_load_state.is_everything_except_player_loaded() {
return;
@ -52,7 +53,8 @@ pub fn player_spawner(
// Spawn player
commands
.spawn(Player)
.spawn(Player(PlayerData::default()))
// Physics
.insert(RigidBody::Dynamic)
.insert(GravityScale(PLAYER_GRAVITY_SCALE))
.insert(Collider::capsule_y(PLAYER_HEIGHT, 2.0))
@ -80,15 +82,19 @@ pub fn player_spawner(
impulse: Vec3::ZERO,
torque_impulse: Vec3::ZERO,
})
// Controller state
.insert(PlayerLinearYState::Falling)
.insert(PlayerLinearXZState::Stopped)
// Engine stuff
.insert(VisibilityBundle {
visibility: Visibility::Visible,
..Default::default()
})
// Data
.insert(PlayerFiringInfo::default())
.push_children(&[camera]);
equipment_change_event_writer.send(EquipmentChangeEvent(player_spawn_point.what.0.equipment.clone()));
commands.entity(player_spawn_point_entity).despawn();
game_load_state.player_loaded = true;
}