fix invalid look directions on teleport

2 files changed, 82 insertions, 71 deletions

diff --git a/azalea-client/tests/clamp_look_direction_on_teleport.rs b/azalea-client/tests/clamp_look_direction_on_teleport.rs
new file mode 100644
index 00000000..10b3215b
--- /dev/null
+++ b/azalea-client/tests/clamp_look_direction_on_teleport.rs
@@ -0,0 +1,81 @@
+use azalea_client::test_utils::prelude::*;
+use azalea_core::{
+    position::{BlockPos, ChunkPos, Vec3},
+    resource_location::ResourceLocation,
+};
+use azalea_entity::LookDirection;
+use azalea_protocol::{
+    common::movements::{PositionMoveRotation, RelativeMovements},
+    packets::{
+        ConnectionProtocol,
+        config::{ClientboundFinishConfiguration, ClientboundRegistryData},
+        game::{
+            ClientboundBlockUpdate, ClientboundPlayerPosition, ServerboundAcceptTeleportation,
+            ServerboundGamePacket,
+        },
+    },
+};
+use azalea_registry::{Block, DataRegistry, DimensionType};
+use simdnbt::owned::{NbtCompound, NbtTag};
+
+#[test]
+fn test_clamp_look_direction_on_teleport() {
+    init_tracing();
+
+    let mut simulation = Simulation::new(ConnectionProtocol::Configuration);
+    let sent_packets = SentPackets::new(&mut simulation);
+
+    simulation.receive_packet(ClientboundRegistryData {
+        registry_id: ResourceLocation::new("minecraft:dimension_type"),
+        entries: vec![(
+            ResourceLocation::new("minecraft:overworld"),
+            Some(NbtCompound::from_values(vec![
+                ("height".into(), NbtTag::Int(384)),
+                ("min_y".into(), NbtTag::Int(-64)),
+            ])),
+        )]
+        .into_iter()
+        .collect(),
+    });
+    simulation.tick();
+    simulation.receive_packet(ClientboundFinishConfiguration);
+    simulation.tick();
+
+    simulation.receive_packet(make_basic_login_packet(
+        DimensionType::new_raw(0), // overworld
+        ResourceLocation::new("minecraft:overworld"),
+    ));
+    simulation.tick();
+
+    sent_packets.expect_tick_end();
+    sent_packets.expect_empty();
+
+    // receive a chunk so the player is "loaded" now
+    simulation.receive_packet(make_basic_empty_chunk(ChunkPos::new(0, 0), (384 + 64) / 16));
+    simulation.receive_packet(ClientboundBlockUpdate {
+        pos: BlockPos::new(1, 1, 3),
+        block_state: Block::Stone.into(),
+    });
+    simulation.receive_packet(ClientboundPlayerPosition {
+        id: 1,
+        change: PositionMoveRotation {
+            pos: Vec3::ZERO,
+            delta: Vec3::ZERO,
+            look_direction: LookDirection::new(-134.99998, 0.0),
+        },
+        relative: RelativeMovements::all_absolute(),
+    });
+    simulation.tick();
+    sent_packets.expect("AcceptTeleportation", |p| {
+        matches!(
+            p,
+            ServerboundGamePacket::AcceptTeleportation(ServerboundAcceptTeleportation { id: 1 })
+        )
+    });
+    sent_packets.expect("MovePlayerPosRot", |p| {
+        let ServerboundGamePacket::MovePlayerPosRot(p) = p else {
+            return false;
+        };
+        p.look_direction == LookDirection::new(225.00002, 0.)
+    });
+}
diff --git a/azalea-client/tests/packet_order.rs b/azalea-client/tests/packet_order.rs
index d4dd2558..014d9f46 100644
--- a/azalea-client/tests/packet_order.rs
+++ b/azalea-client/tests/packet_order.rs
@@ -1,8 +1,4 @@
-use std::{collections::VecDeque, sync::Arc};
-
-use azalea_client::{
-    SprintDirection, StartSprintEvent, packet::game::SendPacketEvent, test_utils::prelude::*,
-};
+use azalea_client::{SprintDirection, StartSprintEvent, test_utils::prelude::*};
 use azalea_core::{
     position::{BlockPos, ChunkPos, Vec3},
     resource_location::ResourceLocation,
@@ -21,8 +17,6 @@ use azalea_protocol::{
     },
 };
 use azalea_registry::{Block, DataRegistry, DimensionType};
-use bevy_ecs::observer::Trigger;
-use parking_lot::Mutex;
 use simdnbt::owned::{NbtCompound, NbtTag};
 
 #[test]
@@ -73,13 +67,10 @@ fn test_packet_order() {
         relative: RelativeMovements::all_absolute(),
     });
     simulation.tick();
-
     assert_eq!(
         simulation.get_block_state(BlockPos::new(1, 1, 3)),
         Some(Block::Stone.into())
     );
-
-    println!("sent_packets: {:?}", sent_packets.list.lock());
     sent_packets.expect("AcceptTeleportation", |p| {
         matches!(
             p,
@@ -160,64 +151,3 @@ fn test_packet_order() {
     sent_packets.expect_tick_end();
     sent_packets.expect_empty();
 }
-
-#[derive(Clone)]
-pub struct SentPackets {
-    list: Arc<Mutex<VecDeque<ServerboundGamePacket>>>,
-}
-impl SentPackets {
-    pub fn new(simulation: &mut Simulation) -> Self {
-        let sent_packets = SentPackets {
-            list: Default::default(),
-        };
-
-        let simulation_entity = simulation.entity;
-        let sent_packets_clone = sent_packets.clone();
-        simulation
-            .app
-            .add_observer(move |trigger: Trigger<SendPacketEvent>| {
-                if trigger.sent_by == simulation_entity {
-                    sent_packets_clone
-                        .list
-                        .lock()
-                        .push_back(trigger.event().packet.clone())
-                }
-            });
-
-        sent_packets
-    }
-
-    pub fn clear(&self) {
-        self.list.lock().clear();
-    }
-
-    pub fn expect_tick_end(&self) {
-        self.expect("TickEnd", |p| {
-            matches!(p, ServerboundGamePacket::ClientTickEnd(_))
-        });
-    }
-    pub fn expect_empty(&self) {
-        let sent_packet = self.next();
-        if let None = sent_packet {
-        } else {
-            panic!("Expected no packet, got {sent_packet:?}");
-        }
-    }
-    pub fn expect(
-        &self,
-        expected_formatted: &str,
-        check: impl FnOnce(&ServerboundGamePacket) -> bool,
-    ) {
-        let sent_packet = self.next();
-        if let Some(sent_packet) = sent_packet {
-            if !check(&sent_packet) {
-                panic!("Expected {expected_formatted}, got {sent_packet:?}");
-            }
-        } else {
-            panic!("Expected {expected_formatted}, got nothing");
-        }
-    }
-    pub fn next(&self) -> Option<ServerboundGamePacket> {
-        self.list.lock().pop_front()
-    }
-}