1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
use std::net::TcpStream;
use anyhow::Result;
use craftio_rs::{CraftSyncReader, CraftSyncWriter, CraftTcpConnection};
use mcproto_rs::protocol::HasPacketKind;
use mcproto_rs::v1_19_3::{Packet761, Packet761Kind, RawPacket761};
#[macro_export]
macro_rules! await_packet {
($packet_type:ident, $conn:expr) => {
assert_packet!(
$packet_type,
$conn.wait_for_packet(Packet761Kind::$packet_type).await?
)
};
}
#[macro_export]
macro_rules! assert_packet {
($packet_type:ident, $obj:expr) => {
if let Packet761::$packet_type(packet_data) = $obj {
packet_data
} else {
panic!("Expected packet of type {}", stringify!($packet_type))
}
};
($packet_type:ident, $conn:expr, $errmgs:literal) => {
assert_packet!(
$packet_type,
$conn
.read_next_packet()
.await?
.ok_or(anyhow::anyhow!("Missing packet"))?
)
};
}
pub struct MinecraftClient {
pub connection: CraftTcpConnection,
}
impl MinecraftClient {
pub fn new(connection: CraftTcpConnection) -> Self {
Self { connection }
}
pub fn from_stream(stream: TcpStream) -> Result<Self> {
Ok(Self {
connection: CraftTcpConnection::from_std(
stream,
mcproto_rs::protocol::PacketDirection::ServerBound,
)?,
})
}
pub async fn read_next_packet(&mut self) -> Result<Option<Packet761>> {
if let Some(raw) = self.connection.read_packet::<RawPacket761>()? {
println!("Client -> Server: {:?}", raw);
Ok(Some(raw))
} else {
Ok(None)
}
}
pub async fn send_packet(&mut self, packet: Packet761) -> Result<()> {
println!("Server -> Client: {:?}", packet);
self.connection.write_packet(packet)?;
Ok(())
}
pub async fn wait_for_packet(&mut self, packet_kind: Packet761Kind) -> Result<Packet761> {
loop {
if let Some(packet) = self.read_next_packet().await? {
if packet.kind() == packet_kind {
return Ok(packet);
}
println!("Skipping packet {:?}", packet);
}
}
}
}
|
