Added basic build mode for structures

cosmos_client/src/entities/player/player_movement.rs

@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::Velocity;
-use cosmos_core::structure::ship::pilot::Pilot;
+use cosmos_core::structure::ship::{build_mode::BuildMode, pilot::Pilot};
 
 use crate::{
     input::inputs::{CosmosInputs, InputChecker, InputHandler},
@@ -15,7 +15,10 @@ use crate::{
 fn process_player_movement(
     time: Res<Time>,
     input_handler: InputChecker,
-    mut query: Query<(Entity, &mut Velocity, &Transform, Option<&PlayerAlignment>), (With<LocalPlayer>, Without<Pilot>)>,
+    mut query: Query<
+        (Entity, &mut Velocity, &Transform, Option<&PlayerAlignment>),
+        (With<LocalPlayer>, Without<Pilot>, Without<BuildMode>),
+    >,
     cam_query: Query<&Transform, With<MainCamera>>,
     parent_query: Query<&Parent>,
     global_transform_query: Query<&GlobalTransform>,

cosmos_client/src/input/inputs.rs

@@ -100,6 +100,9 @@ pub enum CosmosInputs {
     ToggleInventory,
     /// "Shift-Clicking" an item in minecraft
     AutoMoveItem,
+
+    /// Toggles the player between being in build mode and not on a ship
+    ToggleBuildMode,
 }
 
 fn init_input(mut input_handler: ResMut<CosmosInputHandler>) {
@@ -154,6 +157,8 @@ fn init_input(mut input_handler: ResMut<CosmosInputHandler>) {
 
     input_handler.set_keycode(CosmosInputs::ToggleInventory, KeyCode::T);
     input_handler.set_keycode(CosmosInputs::AutoMoveItem, KeyCode::ShiftLeft);
+
+    input_handler.set_keycode(CosmosInputs::ToggleBuildMode, KeyCode::B);
 }
 
 #[derive(Resource, Default, Debug)]

cosmos_client/src/netty/gameplay/receiver.rs

@@ -36,7 +36,12 @@ use cosmos_core::{
         dynamic_structure::DynamicStructure,
         full_structure::FullStructure,
         planet::{biosphere::BiosphereMarker, planet_builder::TPlanetBuilder},
-        ship::{pilot::Pilot, ship_builder::TShipBuilder, Ship},
+        ship::{
+            build_mode::{EnterBuildModeEvent, ExitBuildModeEvent},
+            pilot::Pilot,
+            ship_builder::TShipBuilder,
+            Ship,
+        },
         ChunkInitEvent, Structure,
     },
 };
@@ -173,6 +178,8 @@ pub(crate) fn client_sync_players(
     mut pilot_change_event_writer: EventWriter<ChangePilotEvent>,
     mut requested_entities: ResMut<RequestedEntities>,
     time: Res<Time>,
+
+    (mut build_mode_enter, mut build_mode_exit): (EventWriter<EnterBuildModeEvent>, EventWriter<ExitBuildModeEvent>),
 ) {
     let client_id = transport.client_id();
 
@@ -580,6 +587,24 @@ pub(crate) fn client_sync_players(
                     }
                 }
             }
+            ServerReliableMessages::PlayerEnterBuildMode {
+                player_entity,
+                structure_entity,
+            } => {
+                if let Some(player_entity) = network_mapping.client_from_server(&player_entity) {
+                    if let Some(structure_entity) = network_mapping.client_from_server(&structure_entity) {
+                        build_mode_enter.send(EnterBuildModeEvent {
+                            player_entity,
+                            structure_entity,
+                        });
+                    }
+                }
+            }
+            ServerReliableMessages::PlayerExitBuildMode { player_entity } => {
+                if let Some(player_entity) = network_mapping.client_from_server(&player_entity) {
+                    build_mode_exit.send(ExitBuildModeEvent { player_entity });
+                }
+            }
         }
     }
 }

cosmos_client/src/structure/planet/align_player.rs

@@ -122,7 +122,7 @@ pub enum Axis {
     Z,
 }
 
-#[derive(Debug, Component, Default)]
+#[derive(Debug, Component, Default, Clone, Copy, PartialEq, Eq)]
 /// Used to represent the player's orientation on a planet
 pub struct PlayerAlignment(pub Axis);
 

cosmos_client/src/structure/ship/build_mode.rs

@@ -0,0 +1,109 @@
+//! Handles the build mode logic on the client-side
+
+use bevy::{
+    prelude::{in_state, App, IntoSystemConfigs, Query, Res, ResMut, Transform, Update, Vec3, With, Without},
+    time::Time,
+};
+use bevy_rapier3d::prelude::Velocity;
+use bevy_renet::renet::RenetClient;
+use cosmos_core::{
+    netty::{client_reliable_messages::ClientReliableMessages, cosmos_encoder, NettyChannelClient},
+    structure::{chunk::CHUNK_DIMENSIONSF, ship::build_mode::BuildMode},
+};
+
+use crate::{
+    input::inputs::{CosmosInputs, InputChecker, InputHandler},
+    netty::flags::LocalPlayer,
+    rendering::MainCamera,
+    state::game_state::GameState,
+    structure::planet::align_player::{self, PlayerAlignment},
+};
+
+fn exit_build_mode(
+    input_handler: InputChecker,
+    local_player_in_build_mode: Query<(), (With<LocalPlayer>, With<BuildMode>)>,
+    mut client: ResMut<RenetClient>,
+) {
+    if local_player_in_build_mode.get_single().is_ok() {
+        if input_handler.check_just_pressed(CosmosInputs::ToggleBuildMode) {
+            client.send_message(
+                NettyChannelClient::Reliable,
+                cosmos_encoder::serialize(&ClientReliableMessages::ExitBuildMode),
+            );
+        }
+    }
+}
+
+fn control_build_mode(
+    input_handler: InputChecker,
+    cam_query: Query<&Transform, With<MainCamera>>,
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &mut Velocity, Option<&PlayerAlignment>), (With<LocalPlayer>, With<BuildMode>, Without<MainCamera>)>,
+) {
+    if let Ok((mut transform, mut velocity, player_alignment)) = query.get_single_mut() {
+        velocity.linvel = Vec3::ZERO;
+        velocity.angvel = Vec3::ZERO;
+
+        let cam_trans = transform.mul_transform(*cam_query.single());
+
+        let max_speed: f32 = match input_handler.check_pressed(CosmosInputs::Sprint) {
+            false => 5.0,
+            true => 20.0,
+        };
+
+        let mut forward = cam_trans.forward();
+        let mut right = cam_trans.right();
+        let up = transform.up();
+
+        match player_alignment.copied().unwrap_or_default().0 {
+            align_player::Axis::X => {
+                forward.x = 0.0;
+                right.x = 0.0;
+            }
+            align_player::Axis::Y => {
+                forward.y = 0.0;
+                right.y = 0.0;
+            }
+            align_player::Axis::Z => {
+                forward.z = 0.0;
+                right.z = 0.0;
+            }
+        }
+
+        forward = forward.normalize_or_zero() * max_speed;
+        right = right.normalize_or_zero() * max_speed;
+        let movement_up = up * max_speed;
+
+        let time = time.delta_seconds();
+
+        if input_handler.check_pressed(CosmosInputs::MoveForward) {
+            transform.translation += forward * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveBackward) {
+            transform.translation -= forward * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveUp) {
+            transform.translation += movement_up * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveDown) {
+            transform.translation -= movement_up * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveLeft) {
+            transform.translation -= right * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveRight) {
+            transform.translation += right * time;
+        }
+
+        let max = CHUNK_DIMENSIONSF * 10.0;
+
+        transform.translation = transform.translation.clamp(Vec3::new(-max, -max, -max), Vec3::new(max, max, max));
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (exit_build_mode, control_build_mode).chain().run_if(in_state(GameState::Playing)),
+    );
+}

cosmos_client/src/structure/ship/mod.rs

@@ -11,7 +11,7 @@ use cosmos_core::{
     physics::location::{handle_child_syncing, Location},
     structure::{
         chunk::CHUNK_DIMENSIONSF,
-        ship::{pilot::Pilot, Ship},
+        ship::{build_mode::BuildMode, pilot::Pilot, Ship},
         Structure,
     },
 };
@@ -22,6 +22,7 @@ use crate::{
     state::game_state::GameState,
 };
 
+pub mod build_mode;
 pub mod client_ship_builder;
 pub mod ship_movement;
 
@@ -129,14 +130,14 @@ fn respond_to_collisions(
 }
 
 fn remove_parent_when_too_far(
-    mut query: Query<(Entity, &Parent, &mut Location, &Transform), (With<LocalPlayer>, Without<Ship>)>,
+    mut query: Query<(Entity, &Parent, &mut Location, &Transform), (With<LocalPlayer>, Without<Ship>, Without<BuildMode>)>,
     is_ship: Query<&Location, With<Ship>>,
     mut commands: Commands,
     mut renet_client: ResMut<RenetClient>,
 ) {
     if let Ok((player_entity, parent, mut player_loc, player_trans)) = query.get_single_mut() {
         if let Ok(ship_loc) = is_ship.get(parent.get()) {
-            if player_loc.distance_sqrd(ship_loc).sqrt() >= CHUNK_DIMENSIONSF * 2.0 {
+            if player_loc.distance_sqrd(ship_loc).sqrt() >= CHUNK_DIMENSIONSF * 10.0 {
                 commands.entity(player_entity).remove_parent();
 
                 player_loc.last_transform_loc = Some(player_trans.translation);
@@ -151,6 +152,7 @@ fn remove_parent_when_too_far(
 }
 
 pub(super) fn register(app: &mut App) {
+    build_mode::register(app);
     client_ship_builder::register(app);
     ship_movement::register(app);
 

cosmos_client/src/structure/ship/ship_movement.rs

@@ -8,6 +8,7 @@ use bevy_renet::renet::RenetClient;
 use cosmos_core::netty::client_reliable_messages::ClientReliableMessages;
 use cosmos_core::netty::client_unreliable_messages::ClientUnreliableMessages;
 use cosmos_core::netty::{cosmos_encoder, NettyChannelClient};
+use cosmos_core::structure::ship::build_mode::BuildMode;
 use cosmos_core::structure::ship::pilot::Pilot;
 use cosmos_core::structure::ship::ship_movement::ShipMovement;
 
@@ -19,7 +20,7 @@ use crate::window::setup::DeltaCursorPosition;
 
 fn process_ship_movement(
     input_handler: InputChecker,
-    query: Query<Entity, (With<LocalPlayer>, With<Pilot>)>,
+    query: Query<Entity, (With<LocalPlayer>, With<Pilot>, Without<BuildMode>)>,
     mut client: ResMut<RenetClient>,
     mut crosshair_offset: ResMut<CrosshairOffset>,
     cursor_delta_position: Res<DeltaCursorPosition>,

cosmos_core/src/block/blocks.rs

@@ -174,6 +174,13 @@ fn add_cosmos_blocks(
             .create(),
     );
 
+    blocks.register(
+        BlockBuilder::new("cosmos:build_block", 2.0)
+            .add_property(BlockProperty::Opaque)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
     loading.finish_loading(id, &mut end_writer);
 }
 

cosmos_core/src/block/hardness/mod.rs

@@ -74,6 +74,7 @@ fn register_block_hardness(blocks: Res<Registry<Block>>, mut registry: ResMut<Re
     register_hardness(&mut registry, 100.0, &blocks, "cosmos:ship_core");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:energy_cell");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:reactor");
+    register_hardness(&mut registry, 20.0, &blocks, "cosmos:build_block");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:laser_cannon");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:thruster");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:light");

cosmos_core/src/netty/client_reliable_messages.rs

@@ -89,4 +89,8 @@ pub enum ClientReliableMessages {
         /// The ship the player wants to walk on
         ship_entity: Entity,
     },
+    /// Sent whenever a client wants to exit build mode
+    ///
+    /// Requires server confirmation via [`ServerReliableMessages::PlayerExitBuildMode`] or client will do nothing
+    ExitBuildMode,
 }

cosmos_core/src/netty/server_reliable_messages.rs

@@ -142,4 +142,16 @@ pub enum ServerReliableMessages {
         /// The ship the player is walking on
         ship_entity: Entity,
     },
+    /// Sent when a player enters build mode
+    PlayerEnterBuildMode {
+        /// The player entity on the server
+        player_entity: Entity,
+        /// The structure entity they're building on the server
+        structure_entity: Entity,
+    },
+    /// Sent whenever a player exits build mode
+    PlayerExitBuildMode {
+        /// The server's player entity that's exiting
+        player_entity: Entity,
+    },
 }

cosmos_core/src/structure/ship/build_mode.rs

@@ -0,0 +1,59 @@
+//! Handles build-mode functionality
+//!
+//! Note that build mode is currently only intended for ships, but is not yet manually limited to only ships.
+
+use bevy::prelude::{App, BuildChildren, Commands, Component, Entity, Event, EventReader, Update};
+use bevy_rapier3d::prelude::{RigidBodyDisabled, Sensor};
+
+#[derive(Component, Default)]
+/// Denotes that a player is in build mode
+pub struct BuildMode;
+
+#[derive(Event)]
+/// This event is sent when a player is entering build mode
+pub struct EnterBuildModeEvent {
+    /// The player that's entering build mode
+    pub player_entity: Entity,
+    /// The structure they are entering build mode for
+    ///
+    /// Multiple players can be building on the same structure
+    pub structure_entity: Entity,
+}
+
+#[derive(Event)]
+/// This event is sent when a player is done being in build mode
+pub struct ExitBuildModeEvent {
+    /// The player done being in build mode
+    pub player_entity: Entity,
+}
+
+fn enter_build_mode_listener(mut commands: Commands, mut event_reader: EventReader<EnterBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        let Some(mut ecmds) = commands.get_entity(ev.player_entity) else {
+            continue;
+        };
+
+        ecmds
+            .insert(BuildMode::default())
+            .insert(RigidBodyDisabled)
+            .insert(Sensor)
+            .set_parent(ev.structure_entity);
+    }
+}
+
+fn exit_build_mode_listener(mut commands: Commands, mut event_reader: EventReader<ExitBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        let Some(mut ecmds) = commands.get_entity(ev.player_entity) else {
+            continue;
+        };
+
+        // Keep them as a child of the ship
+        ecmds.remove::<BuildMode>().remove::<RigidBodyDisabled>().remove::<Sensor>();
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(Update, (enter_build_mode_listener, exit_build_mode_listener))
+        .add_event::<EnterBuildModeEvent>()
+        .add_event::<ExitBuildModeEvent>();
+}

cosmos_core/src/structure/ship/mod.rs

@@ -7,6 +7,7 @@ use bevy::prelude::Component;
 use bevy::prelude::States;
 use bevy::reflect::Reflect;
 
+pub mod build_mode;
 pub mod core;
 pub mod pilot;
 pub mod ship_builder;
@@ -21,4 +22,5 @@ pub(super) fn register<T: States + Clone + Copy>(app: &mut App, playing_state: T
     ship_movement::register(app);
     core::register(app, playing_state);
     ship_builder::register(app);
+    build_mode::register(app);
 }