fix(tag): deny placing torches

Author: andrewgazelka

crates/hyperion/src/simulation/blocks/mod.rs

@@ -5,6 +5,7 @@ use std::{future::Future, ops::Try, path::Path, pin::Pin, sync::Arc};
 use anyhow::Context;
 use bytes::Bytes;
 use chunk::Column;
+use derive_more::Constructor;
 use flecs_ecs::{
     core::{Entity, World, WorldGet},
     macros::Component,
@@ -41,6 +42,7 @@ pub enum GetChunk<'a> {
     Loading,
 }
 
+#[derive(Constructor, Debug)]
 pub struct EntityAndSequence {
     pub entity: Entity,
     pub sequence: i32,

crates/hyperion/src/simulation/handlers.rs

@@ -442,8 +442,6 @@ pub fn player_interact_block(
             return Ok(());
         }
 
-        query.inventory.take_one_held();
-
         query.events.push(
             event::PlaceBlock {
                 position,

events/tag/src/module/block.rs

@@ -9,7 +9,7 @@ use flecs_ecs::{
     prelude::Module,
 };
 use hyperion::{
-    BlockKind,
+    BlockKind, chat,
     net::{Compose, NetworkStreamRef, agnostic},
     simulation::{
         Xp,
@@ -43,6 +43,16 @@ pub struct SetLevel {
     pub stage: u8,
 }
 
+impl SetLevel {
+    pub fn new(position: IVec3, stage: u8) -> Self {
+        Self {
+            position,
+            sequence: fastrand::i32(..),
+            stage,
+        }
+    }
+}
+
 pub struct DestroyValue {
     pub position: IVec3,
     pub from: Entity,
@@ -239,45 +249,58 @@ impl Module for BlockModule {
                 }
             });
 
-        system!("handle_placed_blocks", world, &mut Blocks($), &mut EventQueue<event::PlaceBlock>($), &mut PendingDestruction($))
-            .each_iter(move |it, _, (mc, event_queue, pending_air): (&mut Blocks, &mut EventQueue<event::PlaceBlock>, &mut PendingDestruction)| {
+        system!("handle_placed_blocks", world, &mut Blocks($), &mut EventQueue<event::PlaceBlock>($), &mut PendingDestruction($), &Compose($))
+            .each_iter(move |it, _, (mc, event_queue, pending_air, compose): (&mut Blocks, &mut EventQueue<event::PlaceBlock>, &mut PendingDestruction, &Compose)| {
                 let world = it.world();
                 let span = info_span!("handle_placed_blocks");
                 let _enter = span.enter();
-                for event in event_queue.drain() {
-                    let position = event.position;
+                for event::PlaceBlock { position, block, from, sequence } in event_queue.drain() {
+                    if block.collision_shapes().is_empty() {
+                        mc.to_confirm.push(EntityAndSequence::new(from, sequence));
 
-                    mc.set_block(position, event.block).unwrap();
+                        from.entity_view(world).get::<(&mut PlayerInventory, &NetworkStreamRef)>(|(inventory, stream)| {
+                            // so we send update to player
+                            let _ = inventory.get_cursor_mut();
 
-                    event.from.entity_view(world).get::<&mut MainBlockCount>(|main_block_count| {
+                            let msg = chat!("§cYou can't place this block");
+
+                            compose.unicast(&msg, *stream, SystemId(8), &world).unwrap();
+                        });
+
+                        continue;
+                    }
+
+                    mc.set_block(position, block).unwrap();
+
+                    from.entity_view(world).get::<&mut PlayerInventory>(|inventory| {
+                        inventory.take_one_held();
+                    });
+
+                    from.entity_view(world).get::<&mut MainBlockCount>(|main_block_count| {
                         **main_block_count = (**main_block_count - 1).max(0);
                     });
 
                     let destroy = DestroyValue {
                         position,
-                        from: event.from,
+                        from,
                     };
 
+
                     pending_air.destroy_at.schedule(Instant::now() + TOTAL_DESTRUCTION_TIME, destroy);
 
                     {
-                        let sequence = fastrand::i32(..);
                         // Schedule destruction stages 0 through 9
                         for stage in 0_u8..=10 { // 10 represents no animation
                             let delay = TOTAL_DESTRUCTION_TIME / 10 * u32::from(stage);
                             pending_air.set_level_at.schedule(
                                 Instant::now() + delay,
-                                SetLevel {
-                                    position,
-                                    sequence,
-                                    stage,
-                                },
+                                SetLevel::new(position, stage),
                             );
                         }
                     }
                     mc.to_confirm.push(EntityAndSequence {
-                        entity: event.from,
-                        sequence: event.sequence,
+                        entity: from,
+                        sequence,
                     });
                 }
             });