replaced usage of Block Positions with IVec3.

made BlockPosition a wrapper for IVec3 to serialize and deserialize for packets.

Author: Stivais

src/block/rotatable.rs

@@ -1,4 +1,5 @@
 use crate::types::direction::Direction;
+use glam::IVec3;
 
 pub trait Rotatable {
     fn rotate(&self, direction: Direction) -> Self;
@@ -13,19 +14,18 @@ impl Rotatable for f32 {
             Direction::West  => 270.0,
             Direction::Up | Direction::Down => 0.0,
         };
-        // println!("yaw {self} offset {offset} result {}", (self + offset) % 360.0);
         (self + offset) % 360.0
+    }
+}
 
-        // let offset = match dir {
-        //     Direction::North => 0.0,
-        //     Direction::East  => 90.0,
-        //     Direction::South => 180.0,
-        //     Direction::West  => -90.0,
-        //     Direction::Up | Direction::Down => 0.0,
-        // };
-        // let mut result = self + offset;
-        // result = ((result + 180.0) % 360.0) - 180.0;
-        // // println!("yaw {self} offset {offset} result {result}");
-        // result
+impl Rotatable for IVec3 {
+    fn rotate(&self, direction: Direction) -> Self {
+        match direction {
+            Direction::North => Self { x: self.x, y: self.y, z: self.z },
+            Direction::East => Self { x: -self.z, y: self.y, z: self.x },
+            Direction::South => Self { x: -self.x, y: self.y, z: -self.z },
+            Direction::West => Self { x: self.z, y: self.y, z: -self.x },
+            _ => Self { x: self.x, y: self.y, z: self.z },
+        }
     }
 }

src/dungeon/door/door.rs

@@ -1,12 +1,12 @@
 use crate::block::block_parameter::Axis;
 use crate::block::blocks::Blocks;
+use crate::block::rotatable::Rotatable;
 use crate::dungeon::door::door_entity::DoorEntityImpl;
 use crate::dungeon::dungeon::Dungeon;
-use crate::types::block_position::BlockPos;
 use crate::utils::seeded_rng::seeded_rng;
 use crate::world::chunk::chunk_grid::ChunkGrid;
 use crate::world::world::World;
-use glam::DVec3;
+use glam::{ivec3, DVec3, IVec3};
 use rand::prelude::IndexedRandom;
 use std::collections::HashMap;
 
@@ -24,8 +24,8 @@ pub struct Door {
     pub axis: Axis,
     door_type: DoorType,
 
-    inner_start: BlockPos,
-    inner_end: BlockPos,
+    inner_start: IVec3,
+    inner_end: IVec3,
 
     pub is_open: bool,
 }
@@ -39,8 +39,8 @@ impl Door {
             axis,
             is_open: door_type == DoorType::Normal,
             door_type,
-            inner_start: BlockPos::new(x - 1, 69, z - 1),
-            inner_end: BlockPos::new(x + 1, 72, z + 1),
+            inner_start: ivec3(x - 1, 69, z - 1),
+            inner_end: ivec3(x + 1, 72, z + 1),
         }
     }
 
@@ -71,21 +71,21 @@ impl Door {
         // Doors have a thick bedrock floor usually
         chunk_grid.fill_blocks(
             Blocks::Bedrock,
-            BlockPos::new(self.x - dx, 67, self.z - dz),
-            BlockPos::new(self.x + dx, 66, self.z + dz),
+            ivec3(self.x - dx, 67, self.z - dz),
+            ivec3(self.x + dx, 66, self.z + dz),
         );
 
         // Might need to replace with a random palette of cobble, stone, gravel etc if we want to mimic hypixel FULLY, but this works fine.
         chunk_grid.fill_blocks(
             Blocks::Stone { variant: 0 },
-            BlockPos::new(self.x - (dz - 2) * 2, 68, self.z - (dx - 2) * 2),
-            BlockPos::new(self.x + (dz - 2) * 2, 68, self.z + (dx - 2) * 2),
+            ivec3(self.x - (dz - 2) * 2, 68, self.z - (dx - 2) * 2),
+            ivec3(self.x + (dz - 2) * 2, 68, self.z + (dx - 2) * 2),
         );
 
         chunk_grid.fill_blocks(
             Blocks::Air,
-            BlockPos::new(self.x - dx, 69, self.z - dz),
-            BlockPos::new(self.x + dx, 73, self.z + dz),
+            ivec3(self.x - dx, 69, self.z - dz),
+            ivec3(self.x + dx, 73, self.z + dz),
         );
 
         // Pretty much just to get a normal self from a wither one,
@@ -105,7 +105,7 @@ impl Door {
             let y = (index / (5 * 5)) as i32;
             let z = ((index / 5) % 5) as i32;
 
-            let bp = BlockPos::new(x - 2, y, z - 2).rotate(self_direction);
+            let bp = ivec3(x - 2, y, z - 2).rotate(self_direction);
 
             let mut block_to_place = block.clone();
             block_to_place.rotate(self_direction);
@@ -114,8 +114,8 @@ impl Door {
 
         chunk_grid.fill_blocks(
             self.get_block(),
-            BlockPos::new(self.x - 1, 69, self.z - 1),
-            BlockPos::new(self.x + 1, 72, self.z + 1),
+            ivec3(self.x - 1, 69, self.z - 1),
+            ivec3(self.x + 1, 72, self.z + 1),
         );
     }
 
@@ -149,8 +149,8 @@ impl Door {
 
         world.chunk_grid.fill_blocks(
             Blocks::Barrier,
-            BlockPos::new(self.x - 1, 69, self.z - 1),
-            BlockPos::new(self.x + 1, 72, self.z + 1),
+            ivec3(self.x - 1, 69, self.z - 1),
+            ivec3(self.x + 1, 72, self.z + 1),
         );
         // door entity gets rid of blocks when it disappears
         world.spawn_entity(
@@ -167,7 +167,7 @@ impl Door {
     }
 
     // inner bit of door, blocks abilities
-    pub fn contains(&self, block_pos: &BlockPos) -> bool {
+    pub fn contains(&self, block_pos: &IVec3) -> bool {
         let (x ,y , z) = (block_pos.x, block_pos.y, block_pos.z);
         (x >= self.inner_start.x && x <= self.inner_end.x) &&
         (y >= self.inner_start.y && y <= self.inner_end.y) &&

src/dungeon/door/door_entity.rs

@@ -5,7 +5,7 @@ use crate::entity::entity_metadata::{EntityMetadata, EntityVariant};
 use crate::network::binary::var_int::VarInt;
 use crate::network::packets::packet_buffer::PacketBuffer;
 use crate::network::protocol::play::clientbound::{DestroyEntites, EntityAttach, EntityRelativeMove, SpawnMob, SpawnObject};
-use crate::types::block_position::BlockPos;
+use glam::ivec3;
 
 pub struct DoorEntityImpl {
     pub block: Blocks,
@@ -98,8 +98,8 @@ impl EntityImpl<Dungeon> for DoorEntityImpl {
             world.remove_entity(entity.id);
             world.chunk_grid.fill_blocks(
                 Blocks::Air,
-                BlockPos::new(self.x, 69, self.z),
-                BlockPos::new(self.x + 2, 72, self.z + 2),
+                ivec3(self.x, 69, self.z),
+                ivec3(self.x + 2, 72, self.z + 2),
             );
         }
     }

src/dungeon/dungeon.rs

@@ -15,12 +15,11 @@ use crate::player::attribute::{Attribute, AttributeMap, AttributeModifier};
 use crate::player::player::{ClientId, GameProfile, Player};
 use crate::player::sidebar::Sidebar;
 use crate::types::aabb::AABB;
-use crate::types::block_position::BlockPos;
 use crate::types::chat_component::ChatComponent;
 use crate::utils::hasher::deterministic_hasher::DeterministicHashMap;
 use crate::world::world::{World, WorldExtension};
 use anyhow::bail;
-use glam::{DVec3, IVec2};
+use glam::{ivec3, DVec3, IVec2};
 use maplit::hashmap;
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
@@ -138,7 +137,9 @@ impl WorldExtension for Dungeon {
         let entrance = world.extension.entrance_room().clone();
         let entrance = entrance.borrow();
 
-        let position = entrance.get_world_block_pos(&BlockPos::new(15, 72, 18)).as_dvec3_centered();
+        let mut position = entrance.get_world_block_position(ivec3(15, 72, 18)).as_dvec3();
+        position.x += 0.5;
+        position.z += 0.5;
 
         let player = world.spawn_player(
             position,

src/dungeon/dungeon_player.rs

@@ -10,11 +10,11 @@ use crate::network::protocol::play::serverbound::PlayerDiggingAction;
 use crate::player::packet_handling::BlockInteractResult;
 use crate::player::player::{Player, PlayerExtension};
 use crate::player::sidebar::Sidebar;
-use crate::types::block_position::BlockPos;
 use crate::types::chat_component::ChatComponent;
 use crate::types::direction::Direction;
 use crate::world::world::World;
 use chrono::Local;
+use glam::IVec3;
 use indoc::{formatdoc, indoc};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
@@ -71,7 +71,7 @@ impl PlayerExtension for DungeonPlayer {
         });
     }
 
-    fn dig(player: &mut Player<Self>, position: BlockPos, action: &PlayerDiggingAction) {
+    fn dig(player: &mut Player<Self>, position: IVec3, action: &PlayerDiggingAction) {
         let mut restore_block = false;
         match action {
             PlayerDiggingAction::StartDestroyBlock => {
@@ -163,7 +163,7 @@ impl Player<DungeonPlayer> {
         None
     }
 
-    pub fn try_open_door(&mut self, world: &mut World<Dungeon>, position: &BlockPos) {
+    pub fn try_open_door(&mut self, world: &mut World<Dungeon>, position: &IVec3) {
         if world.has_dungeon_started() {
             if let Some(room_rc) = self.get_current_room() {
                 for neighbour in room_rc.borrow().neighbours() {

src/dungeon/room/room.rs

@@ -1,13 +1,13 @@
 use crate::block::blocks::Blocks;
+use crate::block::rotatable::Rotatable;
 use crate::dungeon::door::door::Door;
 use crate::dungeon::dungeon::DUNGEON_ORIGIN;
 use crate::dungeon::room::room_data::RoomData;
 use crate::player::player::ClientId;
 use crate::types::aabb::AABB;
-use crate::types::block_position::BlockPos;
 use crate::types::direction::Direction;
 use crate::world::chunk::chunk_grid::ChunkGrid;
-use glam::dvec3;
+use glam::{dvec3, ivec3, IVec3};
 use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
@@ -104,11 +104,15 @@ impl Room {
         self.segments.iter().flat_map(|seg| seg.neighbours.iter().map(|n| n).flatten())
     }
 
-    pub fn get_corner_pos(&self) -> BlockPos {
+    pub fn get_corner_pos(&self) -> IVec3 {
         Room::get_corner_pos_from(&self.segments, &self.rotation, &self.data)
     }
 
-    pub fn get_corner_pos_from(segments: &[RoomSegment], rotation: &Direction, room_data: &RoomData) -> BlockPos {
+    pub fn get_corner_pos_from(
+        segments: &[RoomSegment],
+        rotation: &Direction,
+        room_data: &RoomData
+    ) -> IVec3 {
         let min_x = segments.iter().min_by(|a, b| a.x.cmp(&b.x)).unwrap().x;
         let min_z = segments.iter().min_by(|a, b| a.z.cmp(&b.z)).unwrap().z;
 
@@ -117,18 +121,18 @@ impl Room {
         let z = min_z as i32 * 32 + DUNGEON_ORIGIN.y;
 
         match rotation {
-            Direction::North => BlockPos { x, y, z },
-            Direction::East => BlockPos { x: x + room_data.length - 1, y, z },
-            Direction::South => BlockPos { x: x + room_data.length - 1, y, z: z + room_data.width - 1 },
-            Direction::West => BlockPos { x: x, y, z: z + room_data.width - 1 },
+            Direction::North => ivec3(x, y, z),
+            Direction::East => ivec3(x + room_data.length - 1, y, z),
+            Direction::South => ivec3(x + room_data.length - 1, y, z + room_data.width - 1),
+            Direction::West => ivec3(x, y, z + room_data.width - 1),
             _ => unreachable!(),
         }
     }
 
     pub fn load_into_world(&self, chunk_grid: &mut ChunkGrid) {
         let corner = self.get_corner_pos();
 
-        for (i, block) in self.data.block_data.iter().enumerate() {
+        for (index, block) in self.data.block_data.iter().enumerate() {
             if *block == Blocks::Air {
                 continue;
             }
@@ -137,13 +141,13 @@ impl Room {
             let mut block = block.clone();
             block.rotate(self.rotation);
 
-            let ind = i as i32;
+            let index = index as i32;
 
-            let x = ind % self.data.width;
-            let z = (ind / self.data.width) % self.data.length;
-            let y = self.data.bottom + ind / (self.data.width * self.data.length);
+            let x = index % self.data.width;
+            let z = (index / self.data.width) % self.data.length;
+            let y = self.data.bottom + index / (self.data.width * self.data.length);
 
-            let bp = BlockPos { x, y, z }.rotate(self.rotation);
+            let bp = ivec3(x, y, z).rotate(self.rotation);
 
             chunk_grid.set_block_at(block, corner.x + bp.x, y, corner.z + bp.z);
         }
@@ -179,13 +183,12 @@ impl Room {
         *old = new;
     }
 
-    pub fn get_world_block_pos(&self, room_pos: &BlockPos) -> BlockPos {
+    pub fn get_world_block_position(&self, room_position: IVec3) -> IVec3 {
         let corner = self.get_corner_pos();
-
-        room_pos.clone()
-            .rotate(self.rotation)
-            .add_x(corner.x)
-            .add_z(corner.z)
+        let mut position = room_position.rotate(self.rotation);
+        position.x += corner.x;
+        position.z += corner.z;
+        position
     }
 }
 

src/main.rs

@@ -12,11 +12,10 @@ use crate::network::packets::packet_buffer::PacketBuffer;
 use crate::network::protocol::play::serverbound::EntityInteractionType;
 use crate::network::run_network::run_network_thread;
 use crate::player::player::Player;
-use crate::types::block_position::BlockPos;
 use crate::utils::seeded_rng::{seeded_rng, SeededRng};
 use crate::world::world::World;
 use anyhow::bail;
-use glam::DVec3;
+use glam::{ivec3, DVec3};
 use rand::prelude::IndexedRandom;
 use std::collections::HashMap;
 use std::time::Duration;
@@ -131,7 +130,9 @@ async fn main() -> anyhow::Result<()> {
 
         let entrance = world.extension.entrance_room();
         let entrance = entrance.borrow();
-        let position = entrance.get_world_block_pos(&BlockPos::new(15, 69, 4)).as_dvec3_centered();
+        let mut position = entrance.get_world_block_position(ivec3(15, 69, 4)).as_dvec3();
+        position.x += 0.5;
+        position.z += 0.5;
 
         let yaw = 0.0.rotate(entrance.rotation);
         world.spawn_entity(

src/network/protocol/play/clientbound.rs

@@ -9,13 +9,13 @@ use crate::network::packets::packet_serialize::PacketSerializable;
 use crate::player::attribute::AttributeMap;
 use crate::player::player::GameProfile;
 use crate::register_packets;
-use crate::types::block_position::BlockPos;
+use crate::types::block_position::BlockPosition;
 use crate::types::chat_component::ChatComponent;
 use crate::types::sized_string::SizedString;
 use blocks::packet_serializable;
 use bytes::BytesMut;
 use enumset::{EnumSet, EnumSetType};
-use glam::Vec3;
+use glam::{IVec3, Vec3};
 use uuid::Uuid;
 
 register_packets! {
@@ -334,14 +334,14 @@ packet_serializable! {
 
 packet_serializable! {
     pub struct BlockChange {
-        pub block_pos: BlockPos,
+        pub block_pos: IVec3 => &BlockPosition(self.block_pos),
         pub block_state: u16 => &VarInt(self.block_state as i32),
     }
 }
 
 packet_serializable! {
     pub struct BlockAction {
-        pub block_pos: BlockPos,
+        pub block_pos: IVec3 => &BlockPosition(self.block_pos),
         pub event_id: u8,
         pub event_data: u8,
         pub block_id: u16 => &VarInt((self.block_id & 4095) as i32),