Merge pull request #17 from temper-mc/feature/proper-block-placing

Basic block placing

Author: ReCore-sys

Cargo.toml

@@ -34,6 +34,8 @@ members = [
     "src/game_systems/src/packets",
     "src/game_systems/src/physics",
     "src/game_systems/src/player",
+    "src/game_systems/src/world",
+    "src/world/block-placing",
     "src/inventories",
     "src/messages",
     "src/net/codec",

src/app/runtime/src/game_loop.rs

@@ -18,7 +18,8 @@ use temper_config::server_config::get_global_config;
 use temper_game_systems::{
     LanPinger, chunk_unloader, keep_alive_system, register_background_systems,
     register_mob_systems, register_packet_handlers, register_physics_systems,
-    register_player_systems, register_shutdown_systems, update_player_ping, world_sync,
+    register_player_systems, register_shutdown_systems, register_world_systems, update_player_ping,
+    world_sync,
 };
 use temper_messages::register_messages;
 use temper_net_runtime::connection::{NewConnection, handle_connection};
@@ -259,6 +260,7 @@ fn build_timed_scheduler() -> Scheduler {
         register_background_systems(s); // Systems that run in the background (day cycle, chunk sending, etc.)
         register_physics_systems(s); // Physics systems (movement, collision, etc.)
         register_mob_systems(s); // Mob AI and behavior
+        register_world_systems(s); // World updates (block changes, redstone, etc.)
     };
     let tick_period = Duration::from_secs(1) / get_global_config().tps;
     timed.register(

src/base/macros/src/block/mod.rs

@@ -162,8 +162,8 @@ pub fn block(input: TokenStream) -> TokenStream {
 
     if matched.is_empty() {
         let properties = get_properties(&filtered_names);
-        if properties.is_empty() {
-            return syn::Error::new_spanned(
+        return if properties.is_empty() {
+            syn::Error::new_spanned(
                 name_str.clone(),
                 format!(
                     "block '{}' has no properties but the following properties were given: {}",
@@ -172,18 +172,18 @@ pub fn block(input: TokenStream) -> TokenStream {
                 ),
             )
             .to_compile_error()
-            .into();
+            .into()
         } else {
-            return syn::Error::new_spanned(
-                    name_str.clone(),
-                    format!(
-                        "no variant of block '{}' matches the specified properties. Available properties: {}",
-                        name_str.clone(), pretty_print_props(&properties)
-                    ),
-                )
-                    .to_compile_error()
-                    .into();
-        }
+            syn::Error::new_spanned(
+                name_str.clone(),
+                format!(
+                    "no variant of block '{}' matches the specified properties. Available properties: {}",
+                    name_str.clone(), pretty_print_props(&properties)
+                ),
+            )
+                .to_compile_error()
+                .into()
+        };
     }
     if matched.len() > 1 {
         return syn::Error::new_spanned(

src/base/macros/src/item/mod.rs

@@ -0,0 +1,43 @@
+use quote::quote;
+use simd_json::prelude::*;
+
+const REGISTRY_FILE: &[u8] = include_bytes!("../../../../../assets/data/registries.json");
+
+pub(super) fn item(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut buf = REGISTRY_FILE.to_vec();
+
+    let parsed = simd_json::to_owned_value(&mut buf).unwrap();
+
+    let target_name = syn::parse_macro_input!(input as syn::LitStr).value();
+
+    let prefixed_name = if target_name.starts_with("minecraft:") {
+        target_name.clone()
+    } else {
+        format!("minecraft:{}", target_name)
+    };
+
+    let id = parsed
+        .get("minecraft:item")
+        .expect("Failed to get 'minecraft:item' from registries.json")
+        .get("entries")
+        .expect("Failed to get 'entries' from 'minecraft:item' in registries.json")
+        .get(&prefixed_name)
+        .unwrap_or_else(|| {
+            panic!(
+                "Failed to find item 'minecraft:{}' in registries.json",
+                prefixed_name
+            )
+        })
+        .get_i32("protocol_id")
+        .unwrap_or_else(|| {
+            panic!(
+                "Failed to get 'protocol_id' for item 'minecraft:{}' in registries.json",
+                prefixed_name
+            )
+        });
+
+    quote! {
+        temper_inventories::item::ItemID(temper_codec::net_types::var_int::VarInt(#id))
+    }
+    .into()
+}

src/base/macros/src/lib.rs

@@ -6,6 +6,7 @@ use proc_macro::TokenStream;
 mod block;
 mod commands;
 mod helpers;
+mod item;
 mod misc;
 mod nbt;
 mod net;
@@ -155,3 +156,18 @@ pub fn match_block(input: TokenStream) -> TokenStream {
 pub fn enum_discriminant(input: TokenStream) -> TokenStream {
     misc::discriminant::enum_discriminant_derive(input)
 }
+
+/// A macro to lookup item IDs at compile time.
+/// Feed in the item name as a string literal, and it will output a [`temper_inventories::item::ItemID`] struct with the correct ID for that item.
+/// Usage:
+/// ```ignore
+/// # use temper_inventories::item::ItemID;
+/// # use temper_macros::item;
+/// let item_id = item!("apple");
+/// assert_eq!(item_id, ItemID::new(temper_codec::VarInt::new(857)));
+/// ```
+/// The `minecraft:` namespace is optional and will be added automatically if not present.
+#[proc_macro]
+pub fn item(input: TokenStream) -> TokenStream {
+    item::item(input)
+}

src/core/Cargo.toml

@@ -21,3 +21,4 @@ temper-nbt = { workspace = true }
 temper-macros = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+once_cell = { workspace = true }

src/core/src/block_state_id.rs

@@ -3,9 +3,11 @@ use ahash::RandomState;
 use bitcode_derive::{Decode, Encode};
 use deepsize::DeepSizeOf;
 use lazy_static::lazy_static;
+use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::process::exit;
+use std::str::FromStr;
 use temper_codec::net_types::var_int::VarInt;
 use tracing::{error, warn};
 
@@ -109,6 +111,10 @@ impl BlockData {
             .to_block_data()
             .expect("Block state ID not found in block mappings file")
     }
+
+    pub fn try_to_block_state_id(&self) -> Option<BlockStateId> {
+        Some(BlockStateId::from_block_data(self))
+    }
 }
 impl From<BlockData> for BlockStateId {
     fn from(block_data: BlockData) -> Self {
@@ -144,3 +150,19 @@ impl Default for BlockStateId {
         Self(0)
     }
 }
+
+const ITEM_TO_BLOCK_MAPPING_FILE: &str =
+    include_str!("../../../assets/data/item_to_block_mapping.json");
+pub static ITEM_TO_BLOCK_MAPPING: Lazy<HashMap<i32, BlockStateId>> = Lazy::new(|| {
+    let str_form: HashMap<String, String> = serde_json::from_str(ITEM_TO_BLOCK_MAPPING_FILE)
+        .expect("Failed to parse item_to_block_mapping.json");
+    str_form
+        .into_iter()
+        .map(|(k, v)| {
+            (
+                i32::from_str(&k).unwrap(),
+                BlockStateId::new(u32::from_str(&v).unwrap()),
+            )
+        })
+        .collect()
+});

src/core/src/pos.rs

@@ -15,7 +15,7 @@ use bitcode_derive::{Decode, Encode};
 use deepsize::DeepSizeOf;
 use temper_codec::net_types::network_position::NetworkPosition;
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct BlockPos {
     /// (i26, i12, i26)
     pub pos: IVec3,

src/game_systems/Cargo.toml

@@ -10,6 +10,7 @@ packets = { path = "./src/packets" }
 physics = { path = "./src/physics" }
 player = { path = "./src/player" }
 shutdown = { path = "./src/shutdown" }
+world = { path = "./src/world" }
 
 bevy_ecs = { workspace = true }
 

src/game_systems/src/lib.rs

@@ -7,3 +7,4 @@ pub use packets::register_packet_handlers;
 pub use physics::register_physics_systems;
 pub use player::{register_player_systems, update_player_ping};
 pub use shutdown::register_shutdown_systems;
+pub use world::register_world_systems;