fix : rebase issues

Author: Tonguechaude

src/components/Cargo.toml

@@ -17,5 +17,4 @@ bitcode_derive = { workspace = true }
 temper-data = { workspace = true }
 bevy_math = { workspace = true }
 uuid = { workspace = true }
-temper-core = { workspace = true }
 type_hash = { workspace = true }

src/game_systems/Cargo.toml

@@ -11,7 +11,7 @@ physics = { path = "./src/physics" }
 player = { path = "./src/player" }
 shutdown = { path = "./src/shutdown" }
 world = { path = "./src/world" }
-interaction = { path = "./src/interaction" }
+interactions = { path = "./src/interactions" }
 
 bevy_ecs = { workspace = true }
 

src/game_systems/src/packets/src/place_block.rs

@@ -2,13 +2,11 @@ use bevy_ecs::message::MessageWriter;
 use bevy_ecs::prelude::{Entity, Query, Res};
 use interactions::block_interactions::is_interactive;
 use temper_codec::net_types::network_position::NetworkPosition;
-use temper_components::bounds::CollisionBounds;
-use temper_codec::net_types::var_int::VarInt;
 use temper_components::player::position::Position;
 use temper_components::{bounds::CollisionBounds, player::sneak::SneakState};
-use temper_core::block_data::BlockData;
 use temper_core::pos::BlockPos;
 use temper_messages::BlockInteractMessage;
+
 use temper_net_runtime::connection::StreamWriter;
 use temper_protocol::PlaceBlockReceiver;
 use temper_protocol::outgoing::block_change_ack::BlockChangeAck;
@@ -44,49 +42,29 @@ pub fn handle(
     )>,
     pos_q: Query<(&Position, &CollisionBounds)>,
     mut world_change: MessageWriter<WorldChange>,
-    mut interact_writer: MessageWriter<BlockInteractMessage>,
+    mut block_interact: MessageWriter<BlockInteractMessage>,
 ) {
     'ev_loop: for (event, eid) in receiver.0.try_iter() {
-        let Ok((entity, conn, inventory, hotbar, pos, rot, sneak_state)) = query.get(eid) else {
+        let Ok((entity, conn, inventory, hotbar, pos, rot, sneak)) = query.get(eid) else {
             debug!("Could not get connection for entity {:?}", eid);
             continue;
         };
         if !state.0.players.is_connected(entity) {
             trace!("Entity {:?} is not connected", entity);
             continue;
         }
-
-        // Convert network position to block position (the block that was clicked)
-        let clicked_pos: BlockPos = event.position.clone().into();
-
-        // Check if the clicked block is interactive and the player is NOT sneaking
+        // If the clicked block is interactive and the player is not sneaking,
+        // dispatch an interaction and skip block placement entirely.
         {
-            let chunk_result = temper_world::World::get_or_generate_mut(
-                &state.0.world,
-                clicked_pos.chunk(),
-                Dimension::Overworld,
-            );
-            let chunk = match chunk_result {
-                Ok(c) => c,
-                Err(e) => {
-                    error!("Failed to load chunk for interaction check: {:?}", e);
-                    continue 'ev_loop;
-                }
-            };
-
-            let clicked_block_state = chunk.get_block(clicked_pos.chunk_block_pos());
-
-            debug!(
-                "PlaceBlock event: pos=({}, {}, {}), clicked_block_state={} (raw: {})",
-                clicked_pos.pos.x,
-                clicked_pos.pos.y,
-                clicked_pos.pos.z,
-                clicked_block_state,
-                clicked_block_state.raw()
-            );
-
-            if !sneak_state.is_sneaking && is_interactive(clicked_block_state) {
-                interact_writer.write(BlockInteractMessage {
+            let clicked_pos: BlockPos = event.position.clone().into();
+            let chunk = state
+                .0
+                .world
+                .get_or_generate_chunk(clicked_pos.chunk(), Dimension::Overworld)
+                .expect("Failed to load chunk for interaction check");
+            let clicked_block = chunk.get_block(clicked_pos.chunk_block_pos());
+            if !sneak.is_sneaking && is_interactive(clicked_block) {
+                block_interact.write(BlockInteractMessage {
                     player: entity,
                     position: clicked_pos,
                     sequence: event.sequence,
@@ -252,7 +230,7 @@ pub fn handle(
 
                         let (block_chunk_x, block_chunk_z) = (block_chunk.x(), block_chunk.z());
                         let render_distance = get_global_config().chunk_render_distance as i32;
-                        for (_, conn, _, _, pos, _) in query.iter() {
+                        for (_, conn, _, _, pos, _, _) in query.iter() {
                             let chunk = pos.chunk();
                             let (chunk_x, chunk_z) = (chunk.x(), chunk.z());
 
@@ -264,11 +242,6 @@ pub fn handle(
                                 error!("Failed to send block update packet: {:?}", err);
                             }
                         }
-                        if let Some(ref upper_update) = upper_half_update
-                            && let Err(err) = conn.send_packet_ref(upper_update)
-                        {
-                            error!("Failed to send block update packet: {:?}", err);
-                        }
                     }
                 }
                 let ack_packet = BlockChangeAck {