Skip to main content

NurtexConnection

nurtex_protocol::connection

Struct NurtexConnection 

Source 
pub struct NurtexConnection { /* private fields */ }
Expand description

Основная структура подключения

Implementations§

Source§

impl NurtexConnection

Source

pub async fn new(address: &NurtexAddr) -> Result<Self>

Метод создания нового подключения

Examples found in repository?
examples/minimal.rs (line 21)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn new_from_stream(stream: TcpStream) -> Result<Self>

Метод создания нового подключения из TcpStream

Source

pub fn get_reader(&self) -> Arc<Mutex<ConnectionReader>>

Метод получения reader

Source

pub fn get_writer(&self) -> Arc<Mutex<ConnectionWriter>>

Метод получения writer

Source

pub async fn get_state(&self) -> ConnectionState

Метод получения текущего состояния подключения

Source

pub async fn set_state(&self, state: ConnectionState)

Метод изменения состояния подключения

Examples found in repository?
examples/minimal.rs (line 37)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn read_packet(&self) -> Option<ClientsidePacket>

Вспомогательный метод чтения пакета

Source

pub fn try_read_packet(&self) -> Result<Option<ClientsidePacket>, Error>

Вспомогательный метод чтения пакета (неблокирующий)

Source

pub fn is_connection_alive(&self) -> bool

Метод проверки активности TCP соединения

Source

pub async fn read_status_packet(&self) -> Option<ClientsideStatusPacket>

Вспомогательный метод чтения status пакета

Source

pub async fn read_login_packet(&self) -> Option<ClientsideLoginPacket>

Вспомогательный метод чтения login пакета

Examples found in repository?
examples/minimal.rs (line 49)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn read_configuration_packet( &self, ) -> Option<ClientsideConfigurationPacket>

Вспомогательный метод чтения configuration пакета

Examples found in repository?
examples/minimal.rs (line 94)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn read_play_packet(&self) -> Option<ClientsidePlayPacket>

Вспомогательный метод чтения play пакета

Examples found in repository?
examples/minimal.rs (line 144)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn write_packet(&self, packet: ServersidePacket) -> Result<()>

Вспомогательный метод записи пакета

Source

pub async fn write_handshake_packet( &self, packet: ServersideHandshakePacket, ) -> Result<()>

Вспомогательный метод записи handshake пакета

Examples found in repository?
examples/minimal.rs (lines 28-33)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn write_status_packet( &self, packet: ServersideStatusPacket, ) -> Result<()>

Вспомогательный метод записи status пакета

Source

pub async fn write_login_packet( &self, packet: ServersideLoginPacket, ) -> Result<()>

Вспомогательный метод записи login пакета

Examples found in repository?
examples/minimal.rs (lines 41-44)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn write_configuration_packet( &self, packet: ServersideConfigurationPacket, ) -> Result<()>

Вспомогательный метод записи configuration пакета

Examples found in repository?
examples/minimal.rs (lines 79-89)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn write_play_packet( &self, packet: ServersidePlayPacket, ) -> Result<()>

Вспомогательный метод записи play пакета

Examples found in repository?
examples/minimal.rs (line 149)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn shutdown(&self) -> Result<()>

Метод выключения соединения

Source

pub async fn set_compression_threshold(&self, threshold: i32)

Метод установки порога сжатия

Examples found in repository?
examples/minimal.rs (line 53)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}
Source

pub async fn set_encryption_key(&self, secret_key: [u8; 16])

Устанавливает шифрование на соединении используя секретный ключ. Этот метод должен быть вызван после отправки EncryptionResponse серверу

Examples found in repository?
examples/minimal.rs (line 59)
16async fn main() -> io::Result<()> {
17  // Конвертируем адрес сервера
18  let addr = convert_address("localhost:25565").unwrap();
19
20  // Создаём подключение (состояние Handshake)
21  let conn = match NurtexConnection::new(&addr).await {
22    Ok(c) => c,
23    Err(_) => return Ok(()),
24  };
25
26  // Отправляем привестствие
27  conn
28    .write_handshake_packet(ServersideHandshakePacket::Greet(ServersideGreet {
29      protocol_version: 774,      // Версия 1.21.11
30      server_host: addr.get_ip(), // Тут рекомендуется указывать имя хоста а не IP-адрес
31      server_port: addr.get_port(),
32      intention: ClientIntention::Login,
33    }))
34    .await?;
35
36  // Меняем состояние подключения на Login
37  conn.set_state(ConnectionState::Login).await;
38
39  // Отправляем пакет LoginStart где указываем имя клиента и UUID (для оффлайн серверов просто нулевой)
40  conn
41    .write_login_packet(ServersideLoginPacket::LoginStart(ServersideLoginStart {
42      username: "NurtexBot".to_string(),
43      uuid: uuid::Uuid::nil(),
44    }))
45    .await?;
46
47  // Создаём цикл для обработки Clientside пакетов в состоянии Login
48  loop {
49    if let Some(p) = conn.read_login_packet().await {
50      match p {
51        ClientsideLoginPacket::Compression(p) => {
52          // Устанавливаем порог сжатия
53          conn.set_compression_threshold(p.compression_threshold).await;
54        }
55        ClientsideLoginPacket::EncryptionRequest(request) => {
56          // Пробуем обработать запрос шифрования
57          if let Some((response, secret_key)) = handle_encryption_request(&request) {
58            conn.write_login_packet(ServersideLoginPacket::EncryptionResponse(response)).await?;
59            conn.set_encryption_key(secret_key).await;
60          }
61        }
62        ClientsideLoginPacket::LoginSuccess(_p) => {
63          // Всё, логин пройден, отправляем LoginAcknowledged и выходим из цикла
64          conn.write_login_packet(ServersideLoginPacket::LoginAcknowledged(ServersideLoginAcknowledged)).await?;
65          break;
66        }
67        _ => {}
68      }
69    } else {
70      break;
71    }
72  }
73
74  // Меняем состояние подключения на Configuration
75  conn.set_state(ConnectionState::Configuration).await;
76
77  // Отправляем опции клиента
78  conn
79    .write_configuration_packet(ServersideConfigurationPacket::ClientInformation(ServersideClientInformation {
80      locale: "en_US".to_string(),
81      view_distance: 10,
82      chat_mode: ChatMode::Enabled,
83      chat_colors: true,
84      displayed_skin_parts: DisplayedSkinParts::default(),
85      main_hand: AccurateHand::Right,
86      enable_text_filtering: false,
87      allow_server_listings: true,
88      particle_status: ParticleStatus::Minimal,
89    }))
90    .await?;
91
92  // Создаём цикл для обработки Clientside пакетов в состоянии Configuration
93  loop {
94    if let Some(p) = conn.read_configuration_packet().await {
95      match p {
96        ClientsideConfigurationPacket::KeepAlive(p) => {
97          // Отправляем ответ на KeepAlive
98          conn
99            .write_configuration_packet(ServersideConfigurationPacket::KeepAlive(nurtex_protocol::packets::configuration::MultisideKeepAlive {
100              id: p.id,
101            }))
102            .await?;
103        }
104        ClientsideConfigurationPacket::Ping(p) => {
105          // Отправляем ответ на Ping
106          conn
107            .write_configuration_packet(ServersideConfigurationPacket::Pong(nurtex_protocol::packets::configuration::ServersidePong { id: p.id }))
108            .await?;
109        }
110        ClientsideConfigurationPacket::KnownPacks(p) => {
111          // Отправляем паки
112          conn
113            .write_configuration_packet(ServersideConfigurationPacket::KnownPacks(ServersideKnownPacks { known_packs: p.known_packs }))
114            .await?;
115        }
116        ClientsideConfigurationPacket::FinishConfiguration(_) => {
117          // Всё, конфигурация пройдена, отправляем AcknowledgeFinishConfiguration и выходим из цикла
118          conn
119            .write_configuration_packet(ServersideConfigurationPacket::AcknowledgeFinishConfiguration(ServersideAcknowledgeFinishConfiguration))
120            .await?;
121          break;
122        }
123        ClientsideConfigurationPacket::AddResourcePack(p) => {
124          // Принимаем ресурс пак
125          conn
126            .write_configuration_packet(ServersideConfigurationPacket::ResourcePackResponse(ServersideResourcePackResponse {
127              uuid: p.uuid,
128              state: ResourcePackState::Accepted,
129            }))
130            .await?;
131        }
132        _ => {}
133      }
134    } else {
135      break;
136    }
137  }
138
139  // Меняем состояние подключения на Play
140  conn.set_state(ConnectionState::Play).await;
141
142  // Создаём цикл обработки пакетов в состоянии Play
143  loop {
144    if let Some(p) = conn.read_play_packet().await {
145      match p {
146        ClientsidePlayPacket::KeepAlive(p) => {
147          // Отправляем ответ на KeepAlive
148          conn
149            .write_play_packet(ServersidePlayPacket::KeepAlive(nurtex_protocol::packets::play::MultisideKeepAlive { id: p.id }))
150            .await?;
151        }
152        ClientsidePlayPacket::Ping(p) => {
153          // Отправляем ответ на Ping
154          conn
155            .write_play_packet(ServersidePlayPacket::Pong(nurtex_protocol::packets::play::ServersidePong { id: p.id }))
156            .await?;
157        }
158        _ => {}
159      }
160    }
161  }
162}

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V