xtex/azalea
1
0
Fork 0
mirror of https://github.com/mat-1/azalea.git synced 2024-09-19 22:52:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'main' into declare-commands-packet

Browse source
This commit is contained in:
mat 2022-04-19 20:35:21 -05:00
commit 58e58dfa8f
8 changed files with 229 additions and 263 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

197
azalea-protocol/packet-macros/src/lib.rs
View file

@ -1,10 +1,12 @@
use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::{self, parse_macro_input, DeriveInput, FieldsNamed};
use syn::{
self, braced,
parse::{Parse, ParseStream, Result},
parse_macro_input, DeriveInput, FieldsNamed, Ident, LitInt, Token,
};
fn as_packet_derive(
input: proc_macro::TokenStream,
state: proc_macro2::TokenStream,
) -> proc_macro::TokenStream {
fn as_packet_derive(input: TokenStream, state: proc_macro2::TokenStream) -> TokenStream {
let DeriveInput { ident, data, .. } = parse_macro_input!(input);
let fields = match data {
@ -99,21 +101,198 @@ fn as_packet_derive(
}
#[proc_macro_derive(GamePacket, attributes(varint))]
pub fn derive_game_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
pub fn derive_game_packet(input: TokenStream) -> TokenStream {
as_packet_derive(input, quote! {crate::packets::game::GamePacket})
}
#[proc_macro_derive(HandshakePacket, attributes(varint))]
pub fn derive_handshake_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
pub fn derive_handshake_packet(input: TokenStream) -> TokenStream {
as_packet_derive(input, quote! {crate::packets::handshake::HandshakePacket})
}
#[proc_macro_derive(LoginPacket, attributes(varint))]
pub fn derive_login_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
pub fn derive_login_packet(input: TokenStream) -> TokenStream {
as_packet_derive(input, quote! {crate::packets::login::LoginPacket})
}
#[proc_macro_derive(StatusPacket, attributes(varint))]
pub fn derive_status_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
pub fn derive_status_packet(input: TokenStream) -> TokenStream {
as_packet_derive(input, quote! {crate::packets::status::StatusPacket})
}
#[derive(Debug)]
struct PacketIdPair {
id: u32,
module: Ident,
name: Ident,
}
#[derive(Debug)]
struct PacketIdMap {
packets: Vec<PacketIdPair>,
}
impl Parse for PacketIdMap {
fn parse(input: ParseStream) -> Result<Self> {
let mut packets = vec![];
loop {
// 0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
// 0x0e
let packet_id: LitInt = match input.parse() {
Ok(i) => i,
Err(_) => break,
};
let packet_id = packet_id.base10_parse::<u32>()?;
// :
input.parse::<Token![:]>()?;
// clientbound_change_difficulty_packet
let module: Ident = input.parse()?;
// ::
input.parse::<Token![::]>()?;
// ClientboundChangeDifficultyPacket
let name: Ident = input.parse()?;
input.parse::<Token![,]>()?;
packets.push(PacketIdPair {
id: packet_id,
module,
name,
});
}
Ok(PacketIdMap { packets })
}
}
#[derive(Debug)]
struct DeclareStatePackets {
name: Ident,
serverbound: PacketIdMap,
clientbound: PacketIdMap,
}
impl Parse for DeclareStatePackets {
fn parse(input: ParseStream) -> Result<Self> {
let name = input.parse()?;
input.parse::<Token![,]>()?;
let serverbound_token: Ident = input.parse()?;
if serverbound_token != "Serverbound" {
return Err(syn::Error::new(
serverbound_token.span(),
"Expected `Serverbound`",
));
}
input.parse::<Token![=>]>()?;
let content;
braced!(content in input);
let serverbound = content.parse()?;
input.parse::<Token![,]>()?;
let clientbound_token: Ident = input.parse()?;
if clientbound_token != "Clientbound" {
return Err(syn::Error::new(
clientbound_token.span(),
"Expected `Clientbound`",
));
}
input.parse::<Token![=>]>()?;
let content;
braced!(content in input);
let clientbound = content.parse()?;
Ok(DeclareStatePackets {
name,
serverbound,
clientbound,
})
}
}
#[proc_macro]
pub fn declare_state_packets(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeclareStatePackets);
let state_name = input.name;
let state_name_litstr = syn::LitStr::new(&state_name.to_string(), state_name.span());
let mut enum_contents = quote!();
let mut id_match_contents = quote!();
let mut write_match_contents = quote!();
let mut serverbound_read_match_contents = quote!();
let mut clientbound_read_match_contents = quote!();
for PacketIdPair { id, module, name } in input.serverbound.packets {
enum_contents.extend(quote! {
#name(#module::#name),
});
id_match_contents.extend(quote! {
#state_name::#name(_packet) => #id,
});
write_match_contents.extend(quote! {
#state_name::#name(packet) => packet.write(buf),
});
serverbound_read_match_contents.extend(quote! {
#id => #module::#name::read(buf).await?,
});
}
for PacketIdPair { id, module, name } in input.clientbound.packets {
enum_contents.extend(quote! {
#name(#module::#name),
});
id_match_contents.extend(quote! {
#state_name::#name(_packet) => #id,
});
write_match_contents.extend(quote! {
#state_name::#name(packet) => packet.write(buf),
});
clientbound_read_match_contents.extend(quote! {
#id => #module::#name::read(buf).await?,
});
}
quote! {
#[derive(Clone, Debug)]
pub enum #state_name
where
Self: Sized,
{
#enum_contents
}
#[async_trait::async_trait]
impl crate::packets::ProtocolPacket for #state_name {
fn id(&self) -> u32 {
match self {
#id_match_contents
}
}
fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
match self {
#write_match_contents
}
}
/// Read a packet by its id, ConnectionProtocol, and flow
async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
id: u32,
flow: &crate::connect::PacketFlow,
buf: &mut T,
) -> Result<#state_name, String>
where
Self: Sized,
{
Ok(match flow {
crate::connect::PacketFlow::ServerToClient => match id {
#serverbound_read_match_contents
_ => panic!("Unknown ServerToClient {} packet id: {}", #state_name_litstr, id),
},
crate::connect::PacketFlow::ClientToServer => match id {
#clientbound_read_match_contents
_ => return Err(format!("Unknown ClientToServer {} packet id: {}", #state_name_litstr, id)),
},
})
}
}
}
.into()
}

1
azalea-protocol/src/mc_buf/write.rs
View file

@ -3,7 +3,6 @@ use azalea_core::{
difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
};
use byteorder::{BigEndian, WriteBytesExt};
use num_traits::FromPrimitive;
use std::io::Write;
use super::MAX_STRING_LENGTH;

87
azalea-protocol/src/packets/game/mod.rs
View file

@ -4,81 +4,16 @@ pub mod clientbound_declare_commands_packet;
pub mod clientbound_login_packet;
pub mod clientbound_update_view_distance_packet;
use super::ProtocolPacket;
use crate::connect::PacketFlow;
use async_trait::async_trait;
use packet_macros::declare_state_packets;
#[derive(Clone, Debug)]
pub enum GamePacket
where
Self: Sized,
{
ClientboundLoginPacket(clientbound_login_packet::ClientboundLoginPacket),
ClientboundUpdateViewDistancePacket(
clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket,
),
ClientboundCustomPayloadPacket(
clientbound_custom_payload_packet::ClientboundCustomPayloadPacket,
),
ClientboundChangeDifficultyPacket(
clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
),
ClientboundDeclareCommandsPacket(
clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket,
),
}
#[async_trait]
impl ProtocolPacket for GamePacket {
fn id(&self) -> u32 {
match self {
GamePacket::ClientboundChangeDifficultyPacket(_packet) => 0x0e,
GamePacket::ClientboundCustomPayloadPacket(_packet) => 0x18,
GamePacket::ClientboundLoginPacket(_packet) => 0x26,
GamePacket::ClientboundUpdateViewDistancePacket(_packet) => 0x4a,
GamePacket::ClientboundDeclareCommandsPacket(_packet) => 0x12,
}
}
fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
match self {
GamePacket::ClientboundChangeDifficultyPacket(packet) => packet.write(buf),
GamePacket::ClientboundCustomPayloadPacket(packet) => packet.write(buf),
GamePacket::ClientboundLoginPacket(packet) => packet.write(buf),
GamePacket::ClientboundUpdateViewDistancePacket(packet) => packet.write(buf),
GamePacket::ClientboundDeclareCommandsPacket(packet) => packet.write(buf),
}
}
/// Read a packet by its id, ConnectionProtocol, and flow
async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
id: u32,
flow: &PacketFlow,
buf: &mut T,
) -> Result<GamePacket, String>
where
Self: Sized,
{
Ok(match flow {
PacketFlow::ServerToClient => match id {
0x0e => clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket
::read(buf)
.await?,
0x18 => clientbound_custom_payload_packet::ClientboundCustomPayloadPacket::read(buf).await?,
0x26 => clientbound_login_packet::ClientboundLoginPacket::read(buf).await?,
0x4a => clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket
::read(buf)
.await?,
0x12 => clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket
::read(buf)
.await?,
// _ => return Err(format!("Unknown ServerToClient game packet id: {}", id)),
_ => panic!("Unknown ServerToClient game packet id: {}", id),
},
PacketFlow::ClientToServer => match id {
// 0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
_ => return Err(format!("Unknown ClientToServer game packet id: {}", id)),
},
})
}
declare_state_packets!(
GamePacket,
Serverbound => {},
Clientbound => {
0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
0x18: clientbound_custom_payload_packet::ClientboundCustomPayloadPacket,
0x26: clientbound_login_packet::ClientboundLoginPacket,
0x4a: clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket,
0x12: clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket
}
);

51
azalea-protocol/src/packets/handshake/mod.rs
View file

@ -1,48 +1,11 @@
pub mod client_intention_packet;
use async_trait::async_trait;
use packet_macros::declare_state_packets;
use crate::connect::PacketFlow;
use super::ProtocolPacket;
#[derive(Clone, Debug)]
pub enum HandshakePacket
where
Self: Sized,
{
ClientIntentionPacket(client_intention_packet::ClientIntentionPacket),
}
#[async_trait]
impl ProtocolPacket for HandshakePacket {
fn id(&self) -> u32 {
match self {
HandshakePacket::ClientIntentionPacket(_packet) => 0x00,
}
}
fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
match self {
HandshakePacket::ClientIntentionPacket(packet) => packet.write(buf),
}
}
/// Read a packet by its id, ConnectionProtocol, and flow
async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
id: u32,
flow: &PacketFlow,
buf: &mut T,
) -> Result<HandshakePacket, String>
where
Self: Sized,
{
match flow {
PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
PacketFlow::ClientToServer => match id {
0x00 => Ok(client_intention_packet::ClientIntentionPacket::read(buf).await?),
_ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
},
}
}
declare_state_packets!(
HandshakePacket,
Serverbound => {},
Clientbound => {
0x00: client_intention_packet::ClientIntentionPacket,
}
);

81
azalea-protocol/src/packets/login/mod.rs
View file

@ -4,76 +4,17 @@ pub mod clientbound_hello_packet;
pub mod clientbound_login_compression_packet;
pub mod serverbound_hello_packet;
use super::ProtocolPacket;
use crate::connect::PacketFlow;
use async_trait::async_trait;
use packet_macros::declare_state_packets;
#[derive(Clone, Debug)]
pub enum LoginPacket
where
Self: Sized,
{
ClientboundCustomQueryPacket(clientbound_custom_query_packet::ClientboundCustomQueryPacket),
ClientboundGameProfilePacket(clientbound_game_profile_packet::ClientboundGameProfilePacket),
ClientboundHelloPacket(clientbound_hello_packet::ClientboundHelloPacket),
ClientboundLoginCompressionPacket(
clientbound_login_compression_packet::ClientboundLoginCompressionPacket,
),
ServerboundHelloPacket(serverbound_hello_packet::ServerboundHelloPacket),
}
#[async_trait]
impl ProtocolPacket for LoginPacket {
fn id(&self) -> u32 {
match self {
LoginPacket::ClientboundCustomQueryPacket(_packet) => 0x04,
LoginPacket::ClientboundGameProfilePacket(_packet) => 0x02,
LoginPacket::ClientboundHelloPacket(_packet) => 0x01,
LoginPacket::ClientboundLoginCompressionPacket(_packet) => 0x03,
LoginPacket::ServerboundHelloPacket(_packet) => 0x00,
}
}
fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
match self {
LoginPacket::ClientboundCustomQueryPacket(packet) => packet.write(buf),
LoginPacket::ClientboundGameProfilePacket(packet) => packet.write(buf),
LoginPacket::ClientboundHelloPacket(packet) => packet.write(buf),
LoginPacket::ClientboundLoginCompressionPacket(packet) => packet.write(buf),
LoginPacket::ServerboundHelloPacket(packet) => packet.write(buf),
}
}
/// Read a packet by its id, ConnectionProtocol, and flow
async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
id: u32,
flow: &PacketFlow,
buf: &mut T,
) -> Result<LoginPacket, String>
where
Self: Sized,
{
Ok(match flow {
PacketFlow::ServerToClient => match id {
0x01 => clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?,
0x02 => {
clientbound_game_profile_packet::ClientboundGameProfilePacket::read(buf).await?
}
0x04 => {
clientbound_custom_query_packet::ClientboundCustomQueryPacket::read(buf).await?
}
0x03 => {
clientbound_login_compression_packet::ClientboundLoginCompressionPacket::read(
buf,
)
.await?
}
_ => return Err(format!("Unknown ServerToClient login packet id: {}", id)),
declare_state_packets!(
LoginPacket,
Serverbound => {
0x00: serverbound_hello_packet::ServerboundHelloPacket,
},
PacketFlow::ClientToServer => match id {
0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
_ => return Err(format!("Unknown ClientToServer login packet id: {}", id)),
},
})
}
Clientbound => {
0x00: clientbound_hello_packet::ClientboundHelloPacket,
0x02: clientbound_game_profile_packet::ClientboundGameProfilePacket,
0x03: clientbound_login_compression_packet::ClientboundLoginCompressionPacket,
0x04: clientbound_custom_query_packet::ClientboundCustomQueryPacket,
}
);

2
azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
View file

@ -36,7 +36,7 @@ pub struct ClientboundStatusResponsePacket {
impl ClientboundStatusResponsePacket {
pub fn get(self) -> StatusPacket {
StatusPacket::ClientboundStatusResponsePacket(Box::new(self))
StatusPacket::ClientboundStatusResponsePacket(self)
}
pub fn write(&self, _buf: &mut Vec<u8>) -> Result<(), std::io::Error> {

67
azalea-protocol/src/packets/status/mod.rs
View file

@ -1,65 +1,14 @@
pub mod clientbound_status_response_packet;
pub mod serverbound_status_request_packet;
use async_trait::async_trait;
use packet_macros::declare_state_packets;
use crate::connect::PacketFlow;
use super::ProtocolPacket;
#[derive(Clone, Debug)]
pub enum StatusPacket
where
Self: Sized,
{
ServerboundStatusRequestPacket(
serverbound_status_request_packet::ServerboundStatusRequestPacket,
),
ClientboundStatusResponsePacket(
Box<clientbound_status_response_packet::ClientboundStatusResponsePacket>,
),
}
#[async_trait]
impl ProtocolPacket for StatusPacket {
fn id(&self) -> u32 {
match self {
StatusPacket::ServerboundStatusRequestPacket(_packet) => 0x00,
StatusPacket::ClientboundStatusResponsePacket(_packet) => 0x00,
}
}
fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
match self {
StatusPacket::ServerboundStatusRequestPacket(packet) => packet.write(buf),
StatusPacket::ClientboundStatusResponsePacket(packet) => packet.write(buf),
}
}
/// Read a packet by its id, ConnectionProtocol, and flow
async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
id: u32,
flow: &PacketFlow,
buf: &mut T,
) -> Result<StatusPacket, String>
where
Self: Sized,
{
match flow {
PacketFlow::ServerToClient => match id {
0x00 => Ok(
clientbound_status_response_packet::ClientboundStatusResponsePacket::read(buf)
.await?,
),
_ => Err(format!("Unknown ServerToClient status packet id: {}", id)),
},
PacketFlow::ClientToServer => match id {
0x00 => Ok(
serverbound_status_request_packet::ServerboundStatusRequestPacket::read(buf)
.await?,
),
_ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
declare_state_packets!(
StatusPacket,
Serverbound => {
0x00: serverbound_status_request_packet::ServerboundStatusRequestPacket,
},
Clientbound => {
0x00: clientbound_status_response_packet::ClientboundStatusResponsePacket,
}
}
}
);