fix: variety of small things (#1265)

* scheduled ticks for banners

* scheduled ticks and can place at for cakes

* add pitch to world spawn and setworldspawn command

* add ability migrate LevelDat from SpawnAngle to SpawnYaw

* backwards compatibility

* use minecraft name for setworldspawn
make PlayerSpawnPosition not panic anymore
fix infinite skipping of night when no players were online

* fix more clippy lints

* send abilities update on initial spawn

* Revert "fix more clippy lints"

This reverts commit 19d4ae5.

* .-.

* implement advance time gamerule

* still tick world_age

* advance weather

* add dropping of inventory on death

* keep inventory gamerule

* clippy

---------

Co-authored-by: CuzImClicks <cuzimclicks@proton.me>
Co-authored-by: Alexander Medvedev <lilalexmed@proton.me>

Author: CuzImClicks

pumpkin-protocol/src/java/client/play/player_spawn_position.rs

@@ -7,12 +7,19 @@ use pumpkin_util::math::position::BlockPos;
 #[derive(Serialize)]
 #[packet(PLAY_SET_DEFAULT_SPAWN_POSITION)]
 pub struct CPlayerSpawnPosition {
+    pub dimension_name: String,
     pub location: BlockPos,
-    pub angle: f32,
+    pub yaw: f32,
+    pub pitch: f32,
 }
 
 impl CPlayerSpawnPosition {
-    pub fn new(location: BlockPos, angle: f32) -> Self {
-        Self { location, angle }
+    pub fn new(location: BlockPos, yaw: f32, pitch: f32, dimension_name: String) -> Self {
+        Self {
+            location,
+            yaw,
+            pitch,
+            dimension_name,
+        }
     }
 }

pumpkin-world/src/world_info/anvil.rs

@@ -236,7 +236,8 @@ mod test {
             spawn_x: 160,
             spawn_y: 70,
             spawn_z: 160,
-            spawn_angle: 0.0,
+            spawn_yaw: 0.0,
+            spawn_pitch: 0.0,
             level_version: 19133,
             world_version: WorldVersion {
                 name: "1.21.4".to_string(),

pumpkin-world/src/world_info/mod.rs

@@ -83,7 +83,11 @@ pub struct LevelData {
     // The Z coordinate of the world spawn.
     pub spawn_z: i32,
     // The Yaw rotation of the world spawn.
-    pub spawn_angle: f32,
+    #[serde(alias = "SpawnAngle")]
+    pub spawn_yaw: f32,
+    // The Pitch rotation of the world spawn.
+    #[serde(default)]
+    pub spawn_pitch: f32,
     #[serde(rename = "Version")]
     pub world_version: WorldVersion,
     #[serde(rename = "version")]
@@ -243,7 +247,8 @@ impl LevelData {
             spawn_x: 0,
             spawn_y: 200,
             spawn_z: 0,
-            spawn_angle: 0.0,
+            spawn_yaw: 0.0,
+            spawn_pitch: 0.0,
             world_version: Default::default(),
             level_version: MAXIMUM_SUPPORTED_LEVEL_VERSION,
         }

pumpkin/src/block/blocks/banners.rs

@@ -1,9 +1,14 @@
-use crate::block::{BlockBehaviour, BlockFuture, OnPlaceArgs};
+use crate::block::{
+    BlockBehaviour, BlockFuture, GetStateForNeighborUpdateArgs, OnPlaceArgs, OnScheduledTickArgs,
+};
 use crate::entity::EntityBase;
 use pumpkin_data::block_properties::{BlockProperties, WhiteBannerLikeProperties};
 use pumpkin_data::tag::{RegistryKey, get_tag_values};
 use pumpkin_macros::pumpkin_block_from_tag;
+use pumpkin_util::math::position::BlockPos;
 use pumpkin_world::BlockStateId;
+use pumpkin_world::tick::TickPriority;
+use pumpkin_world::world::{BlockAccessor, BlockFlags};
 
 #[pumpkin_block_from_tag("minecraft:banners")]
 pub struct BannerBlock;
@@ -16,4 +21,37 @@ impl BlockBehaviour for BannerBlock {
             props.to_state_id(args.block)
         })
     }
+
+    fn can_place_at<'a>(&'a self, args: crate::block::CanPlaceAtArgs<'a>) -> BlockFuture<'a, bool> {
+        Box::pin(async move { can_place_at(args.block_accessor, args.position).await })
+    }
+
+    fn on_scheduled_tick<'a>(&'a self, args: OnScheduledTickArgs<'a>) -> BlockFuture<'a, ()> {
+        Box::pin(async move {
+            if !can_place_at(args.world.as_ref(), args.position).await {
+                args.world
+                    .break_block(args.position, None, BlockFlags::empty())
+                    .await;
+            }
+        })
+    }
+
+    fn get_state_for_neighbor_update<'a>(
+        &'a self,
+        args: GetStateForNeighborUpdateArgs<'a>,
+    ) -> BlockFuture<'a, BlockStateId> {
+        Box::pin(async move {
+            if !can_place_at(args.world, args.position).await {
+                args.world
+                    .schedule_block_tick(args.block, *args.position, 1, TickPriority::Normal)
+                    .await;
+            }
+            args.state_id
+        })
+    }
+}
+
+async fn can_place_at(world: &dyn BlockAccessor, position: &BlockPos) -> bool {
+    let state = world.get_block_state(&position.down()).await;
+    state.is_solid()
 }

pumpkin/src/block/blocks/bed.rs

@@ -238,6 +238,7 @@ impl BlockBehaviour for BedBlock {
                     args.world.dimension,
                     bed_head_pos,
                     args.player.get_entity().yaw.load(),
+                    args.player.get_entity().pitch.load(),
                 )
                 .await
             {

pumpkin/src/block/blocks/cake.rs

@@ -2,8 +2,9 @@ use std::sync::Arc;
 
 use crate::{
     block::{
-        BlockBehaviour, BlockFuture, NormalUseArgs, UseWithItemArgs,
-        blocks::candle_cakes::cake_from_candle, registry::BlockActionResult,
+        BlockBehaviour, BlockFuture, CanPlaceAtArgs, GetStateForNeighborUpdateArgs, NormalUseArgs,
+        OnPlaceArgs, OnScheduledTickArgs, UseWithItemArgs, blocks::candle_cakes::cake_from_candle,
+        registry::BlockActionResult,
     },
     entity::player::Player,
     world::World,
@@ -16,7 +17,11 @@ use pumpkin_data::{
 };
 use pumpkin_macros::pumpkin_block;
 use pumpkin_util::{GameMode, math::position::BlockPos};
-use pumpkin_world::world::BlockFlags;
+use pumpkin_world::{
+    BlockStateId,
+    tick::TickPriority,
+    world::{BlockAccessor, BlockFlags},
+};
 use rand::{Rng, rng};
 
 #[pumpkin_block("minecraft:cake")]
@@ -77,6 +82,19 @@ impl CakeBlock {
 }
 
 impl BlockBehaviour for CakeBlock {
+    fn on_place<'a>(&'a self, args: OnPlaceArgs<'a>) -> BlockFuture<'a, BlockStateId> {
+        Box::pin(async move {
+            if !can_place_at(args.world, args.position).await {
+                return Block::AIR.default_state.id;
+            }
+            Block::CAKE.default_state.id
+        })
+    }
+
+    fn can_place_at<'a>(&'a self, args: CanPlaceAtArgs<'a>) -> BlockFuture<'a, bool> {
+        Box::pin(async move { can_place_at(args.block_accessor, args.position).await })
+    }
+
     fn use_with_item<'a>(
         &'a self,
         args: UseWithItemArgs<'a>,
@@ -146,4 +164,33 @@ impl BlockBehaviour for CakeBlock {
                 .await
         })
     }
+
+    fn on_scheduled_tick<'a>(&'a self, args: OnScheduledTickArgs<'a>) -> BlockFuture<'a, ()> {
+        Box::pin(async move {
+            if !can_place_at(args.world.as_ref(), args.position).await {
+                args.world
+                    .break_block(args.position, None, BlockFlags::empty())
+                    .await;
+            }
+        })
+    }
+
+    fn get_state_for_neighbor_update<'a>(
+        &'a self,
+        args: GetStateForNeighborUpdateArgs<'a>,
+    ) -> BlockFuture<'a, BlockStateId> {
+        Box::pin(async move {
+            if !can_place_at(args.world, args.position).await {
+                args.world
+                    .schedule_block_tick(args.block, *args.position, 1, TickPriority::Normal)
+                    .await;
+            }
+            args.state_id
+        })
+    }
+}
+
+async fn can_place_at(world: &dyn BlockAccessor, position: &BlockPos) -> bool {
+    let state = world.get_block_state(&position.down()).await;
+    state.is_solid()
 }

pumpkin/src/block/blocks/candle_cakes.rs

@@ -7,12 +7,17 @@ use pumpkin_data::{
 };
 use pumpkin_macros::pumpkin_block_from_tag;
 use pumpkin_util::{GameMode, math::position::BlockPos};
-use pumpkin_world::{item::ItemStack, world::BlockFlags};
+use pumpkin_world::{
+    BlockStateId,
+    item::ItemStack,
+    tick::TickPriority,
+    world::{BlockAccessor, BlockFlags},
+};
 
 use crate::{
     block::{
-        BlockBehaviour, BlockFuture, NormalUseArgs, UseWithItemArgs, blocks::cake::CakeBlock,
-        registry::BlockActionResult,
+        BlockBehaviour, BlockFuture, GetStateForNeighborUpdateArgs, NormalUseArgs,
+        OnScheduledTickArgs, UseWithItemArgs, blocks::cake::CakeBlock, registry::BlockActionResult,
     },
     entity::player::Player,
     world::World,
@@ -119,4 +124,33 @@ impl BlockBehaviour for CandleCakeBlock {
             Self::consume_and_drop_candle(args.block, args.player, args.position, args.world).await
         })
     }
+
+    fn on_scheduled_tick<'a>(&'a self, args: OnScheduledTickArgs<'a>) -> BlockFuture<'a, ()> {
+        Box::pin(async move {
+            if !can_place_at(args.world.as_ref(), args.position).await {
+                args.world
+                    .break_block(args.position, None, BlockFlags::empty())
+                    .await;
+            }
+        })
+    }
+
+    fn get_state_for_neighbor_update<'a>(
+        &'a self,
+        args: GetStateForNeighborUpdateArgs<'a>,
+    ) -> BlockFuture<'a, BlockStateId> {
+        Box::pin(async move {
+            if !can_place_at(args.world, args.position).await {
+                args.world
+                    .schedule_block_tick(args.block, *args.position, 1, TickPriority::Normal)
+                    .await;
+            }
+            args.state_id
+        })
+    }
+}
+
+async fn can_place_at(world: &dyn BlockAccessor, position: &BlockPos) -> bool {
+    let state = world.get_block_state(&position.down()).await;
+    state.is_solid()
 }

pumpkin/src/block/blocks/redstone/tripwire_hook.rs

@@ -236,8 +236,8 @@ impl TripwireHookBlock {
             }
         }
 
-        let future_attached = can_attach & (j > 1);
-        let future_powered = wire_attached & future_attached;
+        let future_attached = can_attach && (j > 1);
+        let future_powered = wire_attached && future_attached;
         let mut future_hook_state = TripwireHookProperties::default(&Block::TRIPWIRE_HOOK);
         future_hook_state.attached = future_attached;
         future_hook_state.powered = future_powered;

pumpkin/src/command/commands/setworldspawn.rs

@@ -31,24 +31,18 @@ impl CommandExecutor for NoArgsWorldSpawnExecutor {
         _args: &'a ConsumedArgs<'a>,
     ) -> CommandResult<'a> {
         Box::pin(async move {
-            let Some(block_pos) = sender.position() else {
-                let level_info_guard = server.level_info.read().await;
-                sender
-                    .send_message(TextComponent::translate(
-                        "commands.setworldspawn.success",
-                        [
-                            TextComponent::text(level_info_guard.spawn_x.to_string()),
-                            TextComponent::text(level_info_guard.spawn_y.to_string()),
-                            TextComponent::text(level_info_guard.spawn_z.to_string()),
-                            TextComponent::text(level_info_guard.spawn_angle.to_string()),
-                        ],
-                    ))
-                    .await;
-
-                return Ok(());
+            let Some(player) = sender.as_player() else {
+                if sender.is_console() {
+                    return Err(CommandError::CommandFailed(TextComponent::text(
+                        "You must specify a Position!",
+                    )));
+                }
+                return Err(CommandError::CommandFailed(TextComponent::text(
+                    "Failed to get Sender as Player!",
+                )));
             };
-
-            setworldspawn(sender, server, block_pos.to_block_pos(), 0.0).await
+            let block_pos = player.position();
+            setworldspawn(sender, server, block_pos.to_block_pos(), 0.0, 0.0).await
         })
     }
 }
@@ -67,7 +61,7 @@ impl CommandExecutor for DefaultWorldSpawnExecutor {
                 return Err(InvalidConsumption(Some(ARG_BLOCK_POS.into())));
             };
 
-            setworldspawn(sender, server, *block_pos, 0.0).await
+            setworldspawn(sender, server, *block_pos, 0.0, 0.0).await
         })
     }
 }
@@ -86,11 +80,11 @@ impl CommandExecutor for AngleWorldSpawnExecutor {
                 return Err(InvalidConsumption(Some(ARG_BLOCK_POS.into())));
             };
 
-            let Some(Arg::Rotation(_, yaw)) = args.get(ARG_ANGLE) else {
+            let Some(Arg::Rotation(pitch, yaw)) = args.get(ARG_ANGLE) else {
                 return Err(InvalidConsumption(Some(ARG_ANGLE.into())));
             };
 
-            setworldspawn(sender, server, *block_pos, *yaw).await
+            setworldspawn(sender, server, *block_pos, *yaw, *pitch).await
         })
     }
 }
@@ -100,6 +94,7 @@ async fn setworldspawn(
     server: &Server,
     block_pos: BlockPos,
     yaw: f32,
+    pitch: f32,
 ) -> Result<(), CommandError> {
     let Some(world) = sender.world() else {
         return Err(CommandError::CommandFailed(TextComponent::text(
@@ -121,7 +116,8 @@ async fn setworldspawn(
     level_info_guard.spawn_y = block_pos.0.y;
     level_info_guard.spawn_z = block_pos.0.z;
 
-    level_info_guard.spawn_angle = yaw;
+    level_info_guard.spawn_yaw = yaw;
+    level_info_guard.spawn_pitch = pitch;
 
     drop(level_info_guard);
 
@@ -133,6 +129,8 @@ async fn setworldspawn(
                 TextComponent::text(block_pos.0.y.to_string()),
                 TextComponent::text(block_pos.0.z.to_string()),
                 TextComponent::text(yaw.to_string()),
+                TextComponent::text(pitch.to_string()),
+                TextComponent::text(world.dimension.minecraft_name),
             ],
         ))
         .await;

pumpkin/src/entity/living.rs

@@ -5,6 +5,7 @@ use pumpkin_inventory::build_equipment_slots;
 use pumpkin_inventory::player::player_inventory::PlayerInventory;
 use pumpkin_util::Hand;
 use pumpkin_util::math::position::BlockPos;
+use std::mem;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use std::sync::atomic::{
@@ -808,9 +809,21 @@ impl LivingEntity {
             self.drop_loot(params).await;
             self.entity.pose.store(EntityPose::Dying);
 
-            let level_info = world.level_info.read().await;
-            let game_rules = &level_info.game_rules;
-            if self.entity.entity_type == &EntityType::PLAYER && game_rules.show_death_messages {
+            let block_pos = self.entity.block_pos.load();
+
+            for slot in self.equipment_slots.values() {
+                let item = {
+                    let lock = self.entity_equipment.lock().await;
+                    let equipment = lock.get(slot);
+                    let mut item_lock = equipment.lock().await;
+                    mem::replace(&mut *item_lock, ItemStack::EMPTY.clone())
+                };
+                world.drop_stack(&block_pos, item).await;
+            }
+
+            let show_death_messages =
+                { world.level_info.read().await.game_rules.show_death_messages };
+            if self.entity.entity_type == &EntityType::PLAYER && show_death_messages {
                 //TODO: KillCredit
                 let death_message =
                     Self::get_death_message(&*dyn_self, damage_type, source, cause).await;