ice fill puzzle

Author: Stivais

server/src/constants/sounds.rs

@@ -3,24 +3,28 @@ use bytes::BytesMut;
 
 #[derive(Debug, Copy, Clone)]
 pub enum Sound {
+    RandomWoodClick,
     EnderDragonHit,
     RandomExplode,
     GhastFireball,
     ZombieRemedy,
     FireIgnite,
     DonkeyHit,
+    NoteHarp,
     NoteHat,
 }
 
 impl Sound {
     fn get_sound(&self) -> &'static str {
         match self {
+            Sound::RandomWoodClick => "random.wood_click",
             Sound::EnderDragonHit => "mob.enderdragon.hit",
             Sound::RandomExplode => "random.explode",
             Sound::GhastFireball => "mob.ghast.fireball",
             Sound::ZombieRemedy => "mob.zombie.remedy",
             Sound::FireIgnite => "fire.ignite",
             Sound::DonkeyHit => "mob.horse.donkey.hit",
+            Sound::NoteHarp => "note.harp",
             Sound::NoteHat => "note.hat",
         }
     }

server/src/entity/components/entity_appearance.rs

@@ -4,7 +4,7 @@ use crate::entity::entity_metadata::{EntityMetadata, PlayerMetadata};
 use crate::network::binary::var_int::VarInt;
 use crate::network::packets::packet_buffer::PacketBuffer;
 use crate::network::protocol::play::clientbound::{DestroyEntites, EntityRotate, EntityTeleport, EntityYawRotate, PlayerData, PlayerListItem, SpawnMob, SpawnPlayer};
-use crate::{GameProfile, GameProfileProperty, Player, WorldExtension};
+use crate::{GameProfile, GameProfileProperty, Player, World, WorldExtension};
 use bevy_ecs::component::Mutable;
 use bevy_ecs::prelude::Component;
 use fstr::FString;
@@ -13,6 +13,8 @@ use uuid::Uuid;
 
 pub trait EntityAppearance<W: WorldExtension + 'static>: Component<Mutability = Mutable> + Sized {
 
+    fn init(&self, _world: &mut World<W>) {}
+
     fn enter_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>);
 
     fn leave_player_view(&self, entity: &MinecraftEntity<W>, player: &mut Player<W::Player>);
@@ -162,4 +164,17 @@ fn update_position<W : WorldExtension>(entity: &MinecraftEntity<W>, buffer: &mut
         entity_id: entity.id,
         yaw: entity.yaw,
     });
+}
+
+#[derive(Component)]
+pub struct NoAppearance;
+
+impl<W: WorldExtension + 'static> EntityAppearance<W> for NoAppearance {
+    fn enter_player_view(&self, _: &MinecraftEntity<W>, _: &mut Player<W::Player>) {}
+
+    fn leave_player_view(&self, _: &MinecraftEntity<W>, _: &mut Player<W::Player>) {}
+
+    fn update_position(&self, _: &MinecraftEntity<W>, _: &mut PacketBuffer) {}
+
+    fn destroy(&self, _: &MinecraftEntity<W>, _: &mut DestroyEntites) {}
 }

server/src/entity/entity_metadata.rs

@@ -29,16 +29,8 @@ entity_metadata_serializable! {
             13 => pub is_villager: bool = false,
         },
         Bat {
+            0 => pub flags: u8 = 0,
             16 => pub hanging: bool = false,
         }
     }
-}
-
-
-// entity_metadata_serializable! {
-//     pub enum ObjectMetadata {
-//         FallingBlock {
-//
-//         }
-//     }
-// }
+}

server/src/network/packets/packet_serialize.rs

@@ -118,12 +118,18 @@ impl PacketSerializable for f64 {
     }
 }
 
-impl PacketSerializable for &[u8] {
+impl<T: PacketSerializable> PacketSerializable for &[T] {
     fn write_size(&self) -> usize {
-        self.len()
+        let mut write_size = 0;
+        for entry in self.iter() {
+            write_size += entry.write_size()
+        }
+        write_size
     }
     fn write(&self, buf: &mut BytesMut) {
-        buf.put_slice(self)
+        for entry in self.iter() {
+            entry.write(buf)
+        }
     }
 }
 

server/src/network/protocol/play/clientbound.rs

@@ -61,9 +61,9 @@ register_packets! {
     // BlockBreakAnimation = 0x25;
     // ChunkDataBulk = 0x26;
     // Explosion = 0x27;
-    // Effect = 0x28;
+    Effect = 0x28;
     SoundEffect = 0x29;
-    Particles = 0x2a;
+    Particles<'_> = 0x2a;
     // ChangeGameState = 0x2b;
     // SpawnGlobalEntity = 0x2c;
     OpenWindow = 0x2d;
@@ -367,6 +367,15 @@ packet_serializable! {
     }
 }
 
+packet_serializable! {
+    pub struct Effect {
+        pub effect_id: i32,
+        pub position: IVec3 => &BlockPosition(self.position),
+        pub data: i32,
+        pub disable_relative_volume: bool,
+    }
+}
+
 packet_serializable! {
     pub struct SoundEffect {
         pub sound: Sound,
@@ -379,15 +388,14 @@ packet_serializable! {
 }
 
 packet_serializable! {
-    pub struct Particles {
+    pub struct Particles<'a> {
         pub particle: Particle,
         pub long_distance: bool,
         pub position: Vec3,
         pub offset: Vec3,
         pub speed: f32,
         pub count: i32,
-        // maybe figure out args,
-        // not sure if we'll ever need them
+        pub arguments: &'a [VarInt]
     }
 }
 

server/src/types/aabb.rs

@@ -19,6 +19,13 @@ impl AABB {
             max,
         }
     }
+
+    pub fn new_safe(a: DVec3, b: DVec3) -> Self {
+        Self {
+            min: a.min(b),
+            max: a.max(b),
+        }
+    }
 
     pub const fn intersects(&self, other: &AABB) -> bool {
         self.min.x <= other.max.x && self.max.x >= other.min.x &&

server/src/world/world.rs

@@ -65,6 +65,19 @@ impl<W: WorldExtension + 'static> World<W> {
     pub fn write_global_packet<P : IdentifiedPacket + PacketSerializable>(&mut self, packet: &P) {
         self.global_packet_buffer.write_packet(packet)
     }
+    
+    pub fn write_local_packet<P : IdentifiedPacket + PacketSerializable>(
+        &mut self,
+        position: DVec3,
+        packet: &P,
+    ) {
+        let chunk_x = (position.x.floor() as i32) >> 4;
+        let chunk_z = (position.z.floor() as i32) >> 4;
+
+        if let Some(chunk) = self.chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
+            chunk.packet_buffer.write_packet(packet)
+        }
+    }
 
     pub fn spawn_player(
         &mut self,
@@ -158,7 +171,9 @@ impl<W: WorldExtension + 'static> World<W> {
             yaw,
             pitch
         );
-        
+
+        appearance.init(self);
+
         // kinda scuffed ngl
         self.entities.register_appearance_update::<T>();
 
@@ -184,6 +199,17 @@ impl<W: WorldExtension + 'static> World<W> {
     }
 
     pub fn spawn_particle(&mut self, particle: Particle, position: Vec3, offset: Vec3, count: i32) {
+        self.spawn_particle_with_args(particle, position, offset, count, Vec::new());
+    }
+
+    pub fn spawn_particle_with_args(
+        &mut self,
+        particle: Particle,
+        position: Vec3, 
+        offset: Vec3,
+        count: i32,
+        arguments: Vec<VarInt>
+    ) {
         let chunk_x = (position.x.floor() as i32) >> 4;
         let chunk_z = (position.z.floor() as i32) >> 4;
 
@@ -195,24 +221,20 @@ impl<W: WorldExtension + 'static> World<W> {
                 offset,
                 speed: 0.0,
                 count,
+                arguments: &arguments
             })
         }
     }
 
     pub fn play_sound_at(&mut self, sound: Sound, volume: f32, pitch: f32, position: DVec3) {
-        let chunk_x = (position.x.floor() as i32) >> 4;
-        let chunk_z = (position.z.floor() as i32) >> 4;
-
-        if let Some(chunk) = self.chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
-            chunk.packet_buffer.write_packet(&SoundEffect {
-                sound,
-                pos_x: position.x,
-                pos_y: position.y,
-                pos_z: position.z,
-                volume,
-                pitch,
-            })
-        }
+        self.write_local_packet(position, &SoundEffect {
+            sound,
+            pos_x: position.x,
+            pos_y: position.y,
+            pos_z: position.z,
+            volume,
+            pitch,
+        });
     }
 
     pub fn remove_player(&mut self, client_id: ClientId) {

src/dungeon/door/door.rs

@@ -1,13 +1,14 @@
-use crate::dungeon::door::door_entity::DoorEntity;
 use crate::dungeon::dungeon::Dungeon;
+use crate::dungeon::entities::block_appearance::BlockAppearance;
+use crate::dungeon::entities::moving_block_behaviour::MovingBlockBehaviour;
 use crate::dungeon::seeded_rng::seeded_rng;
-use glam::{ivec3, DVec3, IVec3};
+use glam::{dvec3, ivec3, IVec3};
 use rand::prelude::IndexedRandom;
 use server::block::block_parameter::{Axis, BlockColor};
 use server::block::rotatable::Rotate;
 use server::block::Block;
 use server::utils::hasher::deterministic_hasher::DeterministicHashMap;
-use server::world::chunk::chunk_grid::ChunkGrid;
+use server::world::chunk::chunk_grid::{iterate_blocks, ChunkGrid};
 use server::World;
 
 #[derive(Hash, Eq, PartialEq)]
@@ -145,18 +146,27 @@ impl Door {
         }
 
         self.is_open = true;
-        
-        world.chunk_grid.fill_blocks(
-            Block::Barrier,
+
+        iterate_blocks(
             ivec3(self.x - 1, 69, self.z - 1),
             ivec3(self.x + 1, 72, self.z + 1),
+            |x, y, z| {
+                world.spawn_entity(
+                    dvec3(x as f64 + 0.5, y as f64, z as f64 + 0.5),
+                    0.0,
+                    0.0,
+                    BlockAppearance {
+                        block: self.get_block(),
+                    },
+                    MovingBlockBehaviour {
+                        block: ivec3(x, y, z),
+                        total_ticks: 20,
+                        difference: -0.25,
+                    }
+                );
+                world.chunk_grid.set_block_at(Block::Barrier, x, y, z);
+            }
         );
-
-        DoorEntity::spawn_into_world(
-            world,
-            DVec3::new(self.x as f64 - 1.0, 69.0, self.z as f64 - 1.0),
-            self.get_block()
-        )
     }
 
     // inner bit of door, blocks abilities