Как написать свое ядро для сервера майнкрафт

1. Как написать своё ядро.
   ​

   Приветствую вас, вы читаете статью о том, где сумасшедший вроде меня будет объяснять вам как написать своё ядро для серверов майнкрафт. Подразумевается, что эта статья — объяснение документации простыми словами.

   Начало.
   Для начала, нам нужно определиться с языком и некоторыми другими вещами. В этой статье мы будем использовать Python 3, так как он более лёгкий для новичков, а ещё потому, что мне так захотелось. Так же стоит определиться где мы будем писать, а именно в каком IDE. Нет, вы конечно можете использовать удобные Nano и Vim, но не все люди любят терминалы. Я могу предложить вам несколько IDE.

   1. Visual Studio Code. Поделка Microsoft. Присутствует версия DEB.
   2. PyCharm. Поделка JetBrains. Как по мне его минус — написан он на java. Отсутствует DEB.
   3. Sublime Text. Поделка не знаю кого. Это вообще не IDE. DEB присутствует.

   Когда мы выбрали IDE, можно приступать к созданию проекта. Лично я буду пользоваться Visual Studio, так как он мне удобнее. Надо бы создать проект. Как делать это, показывать не буду — Вам нечего делать тут если вы не знаете как создавать проект в своей IDE. После того как у нас есть пустая папка, нам надо создать скелет проекта. Первое что мы создадим будет файлом requirements.txt. Он нужен для удобной установки зависимостей. В него мы будем писать названия всех библиотек которые используем. После создания сразу запишем туда строчки.

   Это наши две зависимости. Поясню, quarry — библиотека для удобной работы с протоколом майнкрафт, а loguru это просто рай для программиста, она позволяет работать с логами очень удобно. Далее мы создадим виртуальное окружение которое нужно, чтобы не засорять систему разными библиотеками нужными для проекта. Сделать это легко и просто можно командой:

   $ virtualenv venv -p python3

   У нас создастся как бы «отдельная система» с установленным питоном 3-ей версии. Теперь надо войти в это окружение. Для этого используем команду:

   $ source venv/bin/activate

   Теперь надо бы установить все наши зависимости, сделаем это через PiP:

   $ pip install -r requirements.txt

   Нам осталось совсем немного. Создадим лишь файл оболочки в корневой папке для запуска проекта. В моём случае это будет start.sh. Он пока остаётся пустым, так как самой «начинки» у нас ещё нету.

   Библиотека Quarry
   Как было упомянуто ранее, для работы с протоколом мы будем использовать библиотеку quarry. Более 90% работы она будет выполнять за нас. Первым делом, давайте создадим главную папку, пусть она называется так же как и проект, только с маленькой буквы. В ней мы создадим файл main.py. Он будет служить стартовой точкой для программы, будет разбирать аргументы и запускать сам сервер. Давайте напишем в него примерно такой код:

   from loguru import logger # Логирование
   import argparse # Аргументы
   
   def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("-m", "--motd", default="Test!", type=str, help="Server motd")
     args = parser.parse_args()
     logger.add("latest.log", rotation="5 MB")
     logger.info("All works!")
   
   main()

   Этот короткий код-заготовка при запуске вызовет главную функцию, распарсит аргументы и положит их в args. После этого создастя файл latest.log который будет пересоздаваться каждый раз когда будет достигать 5 MB веса и выведется сообщение «All works!». Окей, давайте теперь напишем основную логику. Создадим файл с любым названием. Теперь нам нужно создать для него некоторую заготовку. Для этого импортируем некоторые классы.

   from twisted.internet import reactor
   from quarry.net.server import ServerProtocol, ServerFactory

   Далее, нам нужно создать классы наследники.

   class ExampleProtocol(ServerProtocol):
   
     def player_joined(self): # Игрок зашёл
       ServerProtocol.player_joined(self) # Базовые действия при заходе игрока
       self.close("You disconnected because you {0}".format(self.display_name)) # Кикаем игрока по причине "You disconnected because you [имя игрока]"
   
   class ExampleFactory(ServerFactory):
     protocol = ExampleProtocol # Устанавливаем протокол
     motd = "My shiny test motd!" # Устанавливаем мотд для сервера

   На этом и подошла к концу первая часть. Вторую я напишу, если эта часть окажется хоть кому то полезной и/или интересной. Хочу отметить, что созданный проект не дописан и не должен работать.

   Последнее редактирование: 4 окт 2020



2. Это ответ тем, кто говорил, что мне стоит написать туториал о чём то оригинальном.

   Последнее редактирование: 4 окт 2020

3. Как написать своё ядро. Часть II.
   ​

   Приветствую вас, вы читаете продолжение статьи о том, где сумасшедший вроде меня наконец изъяснится до конца вам о том, как написать ядро для сервера майнкрафт. Если вы не видели 1-ую статью, советую прочитать сначала её. Цель данной статьи — показать, насколько легко написать своё ядро.

   Продолжение
   Вспомним про наш уже существующий проект и допишем его. Определимся с целью нашего ядра, давайте сплагиатим небольшую часть из моего проекта и будет генерировать для каждого игрока отдельный токен. Входим в виртуальное окружение и открываем все нужные файлы в нашем IDE.

   Приступим к написанию кода. Сначала напишем логику самого сервера. Импортируем библиотеку secrets(она стандартная для python3 и заносить в requirements.txt её не надо)

   Данная библиотека поможет нам в генерации ключа игрока. Добавим пару строчек перед этим.

   self.close("You disconnected because you {0}".format(self.display_name))

   Вот, что мы допишем.

   token = secrets.hex(5) # 5 - Длина ключа, может быть любой

   Данный код сгенерирует HEX-последовательность и положит её в переменную token. Далее нам надо немного подправить файл main.py где обрабатываются аргументы. Добавим в него несколько аргументов. Вот что у нас получится.

   from loguru import logger # Логирование
   import argparse # Аргументы
   
   def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("-a", "--api", required=True type=str, help="HTTPS API to send requests")
     parser.add_argument("-A", "--api-token", required=True, type=str, help="API  TOKEN for authorization.")
     args = parser.parse_args()
     logger.add("latest.log", rotation="5 MB")
     logger.info("All works!")
   
   main()

   Теперь для запуска нашего сервера, обязательно надо будет указать адрес сайта, на который будет отправляться POST запрос с данными и токен, чтобы сайт мог определить, что запрос именно от нашего сервера. В основном файле нам осталось только отправить запрос. Но сначала мы доделаем файл main.py. Допишем в наш основной файл функцию(не относящуюся к какому либо классу).

   def main(args):
     f = ExampleFactory()
     f.api = args.api
     f.token = args.api_token
     f.listen('localhost', 25565)
     reactor.run()

   Она нужна для того, чтобы мы могли вызвать её из main.py передав аргументы как аргумент. Разберём её подробнее, в ней мы создаём экземпляр фабрики и устанавливаем несколько переменных у этого экземпляра. Это нужно для того, чтобы мы могли получить эти переменные в классе-протоколе. Дальше, мы заставляем фабрику слушать ‘localhost’ на порте 25565(стандартный порт майнкрафт серверов). Теперь мы можем со спокойной совестью импортировать эту функцию в main.py и вызвать её. Наш сервер уже способен запуститься и генерировать токен на каждого игрока. Давайте кстати изменим причину кика в основном файле на причину содержащую токен. Например «Your token is: [token]». Остаётся только отправить запрос, это сделаем при помощи стандартной библиотеки request. Импортируем её.Определим несколько переменных отвечающих за данные запроса и его хёдеры. Назовём их к примеру headers и data. Это всё должно находиться перед закрытием соединения. Вот что мы допишем.

   headers = {"Authorization":"Bearer " + self.factory.token}
   data = {"token":token,"username":self.display_name,"uuid":self.uuid}

   Разберёмся. Начнём с хёдеров, первым и единственным у нас будет хёдер Authorization. Он служит в запросах для авторизации в чём то или где то. Мы используем его для того, чтобы сказать серверу о том что это мы. Дальше идёт переменная data — тело запроса. Оно содержит такие параметры как token — токен сгенерированный для пользователя в коде выше, username — имя пользователя(игрока), uuid — UUID игрока. Давайте отправим это всё дело на сервер при помощи данного кода.

   try:
     request = requests.post(self.factory.api, headers=headers, data=data)
   except:
     self.logger.error("HTTP API cannot be requested.")
     self.close("Internal Server Error")

   В данном коде мы пробуем отправить POST-запрос на адрес из переменной api в фабрике с хёдерами headers и с данными data. Если возникает ошибка — печатаем в консоль повесть о том, что мы не можем достучаться до сервера и закрываем соединение с пользователем по причине «Internal Server Error».

   Открываем файл оболочки(у меня start.sh) и записываем туда команду для вызова main.py файла.

   Вот впринципе и всё.

4. 
   

   iForgotPassword
   Активный участник
   Пользователь

   Баллы:

   66

   Имя в Minecraft:

   iForgotPassword

   Интересно, но так бессмысленно…
   Почему Python?
   Это не ядро, а какой-то скрипт, который выводит motd и кикает при коннекте.
   Тема интересная, развития никакого, к сожалению.

5. Я дал лишь основу, чтобы из этого можно было сделать что либо ещё, по своей задумке. Python разве не легче для понимания и не занимает меньше оперативы? К тому же библиотека Quarry благодаря которой я написал статью, попалась мне на глаза первее, чем любая библиотека под яву(Они вообще такие есть под неё?).

6. 
   

   iForgotPassword
   Активный участник
   Пользователь

   Баллы:

   66

   Имя в Minecraft:

   iForgotPassword

   Я твой посыл понял, лайк бы поставил на теме. Мне не понравилось то, что как-то не до конца раскрыта тема, наверное. Не знаю.
   Не уверен, что прочитав эту статью кто-то захочет написать свое ядро сервера, да и к тому же на Python, когда все вокруг Minecraft крутится на Java. Java — де-факто для мира Minecraft и никакой другой язык в ближайшее время его не заменит. К тому же, менять Java на Python плохая идея т.к Python еще менее производительнее чем Java (как минимум из-за того, что Python интерпретируемый язык). К тому же, количество выделяемой памяти под приложение Java/Python не играет роли, если итоговая производительность приложения ниже.
   Я точно не знаю как создаются ядра для серверов, но, если я не ошибаюсь, есть ядро Bukkit, а все остальное — его форки в той или иной степени.
   Также при написании своего ядра на Python возникнет ряд проблем с интеграцией Java плагинов.
   Да и в целом Python не предназначен для высоконагруженной системы (могу ошибаться)

7. Java к слову майнкрафт скорее всего выбрал не потому что им так захотелось, а потому что он просто кроссплатформенный. Но компиляция Java насколько знаю — не превращение кода в бинарник, Java кроссплатформенная из за принципа её работы. Она компилирует приложение в понятный для себя байткод, его к слову прочитать можно легко и без особых проблем, а только потом уже при запуске она превращает его в понятный для машины код(это всё не точно, я не обновлял знания по работе Java давно). А выделенная оперативка играет роль, так как чем меньше надо оперативки — тем лучше, ведь запустить прогу ты сможешь на машине с характеристиками чуть хуже. А на счёт Bukkit — необязательно, это не какой то закон.

8. 
   

   iForgotPassword
   Активный участник
   Пользователь

   Баллы:

   66

   Имя в Minecraft:

   iForgotPassword

   Java выбрал Маркус Перссон т.к он на нем изначально программировал => все последующее развитие Minecraft на Java.

   Java являются JIT-компилируемыми. Для JIT-компиляции требуется промежуточный язык, позволяющий разбивать код на блоки (или фреймы).  Сам по себе JIT не делает выполнение быстрее, ведь он по-прежнему выполняет те же последовательности байт-кода. Однако, он позволяет выполнять оптимизацию в рантайме. Хороший JIT-оптимизатор видит, какие части приложения выполняются чаще, и помечает их тегом "hot spot", чтобы в следующий раз выполнение прошло быстрее.
   

   Сейчас заканчивается 2020г, а не 90-00, когда размер памяти играл большую роль.
   К тому же, зачем тебе много оперативки, если у тебя стоит никчемный процессор? Оперативная память нужна для того, чтобы хранить в ней какие-то данные и быстро ими манипулировать. А т.к у нас не текстовый редактор а сервер, то нам нужна многопоточность и быстрота процессора => оперативная память на втором месте. Если у тебя будет все тупить в следствие того, что процессор не может обработать такое кол-во операций, то пиши пропало, оператос не спасет.

9. Так поэтому и хорошо делать программы с мелким потреблением оперативы, чтобы ты мог вбухать больше денег в процессор и при этом программа всё равно запустилась. Да и вообще, всегда будет лучше, если программа требует меньше ресурсов.

10. 
    

    iForgotPassword
    Активный участник
    Пользователь

    Баллы:

    66

    Имя в Minecraft:

    iForgotPassword

    Разница в количестве потребляемой оперативной памяти не такая большая, чтобы пренебрегать скоростью работы

11. Ну и в конце концов, этоn конечно скорее всего не будет применяться для написания таких вещей где важна скорость работы буквально RealTime.

12. 
    

    iForgotPassword
    Активный участник
    Пользователь

    Баллы:

    66

    Имя в Minecraft:

    iForgotPassword

    

13. Этот quarry в любом случае нигде не будет применятся да. Ибо это не ядро, а пустой протокол майна. Внутри него ничего нет. И таких протоколов много на гитхабе, даже на node js есть

14. Бред.
    Сейчас все еще смотрят на бенчи. Все что быстрее эквивалентно тому что это лучше.
    Большую роль играет удобство, но если у тебя всё хавает тонну озу и нагружает процессор до предела — люди будут перестраиваться под другой продукт.
    Ну есть майн на плюсах который намного производительнее оригинала т.к не содержит тонны абстракций на абстракциях, глупые реализации простейших вещей, и прочее.

    ладно…….

    ТС’у:
    Тема полнейший бред, это не ядро.
    Это больше похоже на какую-то проксю для обработки запросов с клиента.

15. 
    

    SimMiMo
    Активный участник
    Пользователь

    Сейчас обычный недорогой дедик имеет 32-64 гб памяти и это все будет дешеветь с каждым годом.
    Майн на мобилу.. покет едишн. Если честно, под него вообще нормальных ядер нет, одно говно.
    Да и любителей телефончиков не настолько чтобы дофига. Не представляю, как там пэхаться.
    Но опять же, это не вина самого майна пе.

    Последнее редактирование: 20 окт 2020
16. 
    

    iForgotPassword
    Активный участник
    Пользователь

    Баллы:

    66

    Имя в Minecraft:

    iForgotPassword

    майнна плюсах это же Bedrock edition, то бишь PE, PS4 и пр. что != Java edition

17. Дак бедрок есть не только на телефоны o_0
    Что ****ь за бред ты несешь? Причём тут то что он не Java Edition? Мы говорим то что он в разы производительнее чем оригинал (даже если убрать тот факт что он нативный), т.к в нём нету сотни тысяч абстракций, глупых реализаций, и просто врапперов над врапперами.
    Каждый прыжок по сегментам занимает кучу времени, особенно если забить на то что твой код нужно оптимизировать т.к ты работаешь через виртуалку.
    Инфляция это who

18. Так потому он и прекрасен, он уже убирает мороку с подключением и даёт какой никакой API для работы с пакетами. При этом над пакетами play у тебя есть полный контроль. К тому же там есть примеры, из который вполне будет понятно как реализовать определённую вещь.

19. Ну дает и что? А серверлогики то нет. Портировать весь кубач на питон? Ну такое.

В данном посте я планирую сделать лишь основы, поэтому в следующей части будет больше интересного).

Сначала я бы хотел уточнить, что буду использовать Go последней версии (на момент поста 1.17.5), а так-же редактор GoLand от JetBrains и буду надеяться на вашу поддержу
Пока на самом начале сервер будет поддерживаться только на 1.12.2, потому-что моё супер вычислительное устройство очень плохо работает в связке GoLand + Minecraft 1.16.5 и выше.

[package]
name = "ule"
version = "0.1.0"
edition = "2021"
publish = true
authors = [
    "Distemi <distemi.bot@mail.ru>"
]
homepage = "https://github.com/Distemi/ULE"
repository = "https://github.com/Distemi/ULE"

[dependencies]
# Быстрый HashMap и другое.
ahash = "0.7.6"
# Глобальные переменные
lazy_static = "1.4.0"
# Struct <-> JSON
serde = { version = "1.0.136", features = ["derive"] }
serde_json = "1.0.78"
# Утилиты логирования
log = "0.4.14"
fern = { version = "0.6", features = ["colored"] }
# Время
chrono = "0.4.19"
# Асинхронность(скоро точно понадобится)
async-std = "1.10.0"

# Однопоточный TCP и UDP сервер
[dependencies.mio]
version = "0.8.0"
default-features = false
features = [
    "os-ext",
    "net"
]


[profile.release]
opt-level = "z"

#![allow(unused_must_use)]
use crate::config::{ADDRESS, ADDRESS_PORT};
use crate::logger::start_input_handler;
use crate::network::network_server_start;
use fern::colors::Color;
use std::error::Error;
use std::process;
use std::sync::mpsc::channel;
use std::sync::Arc;
use std::time::SystemTime;
use std::{fmt, thread};
use utils::logger;

// Use a macros from serde(Serialize and Deserialize), log(Logging) and lazy_static(Global variables)
#[macro_use]
extern crate serde;
#[macro_use]
extern crate log;
#[macro_use]
extern crate lazy_static;

pub mod config;
pub mod network;
pub mod utils;

// Main function of application
fn main() {
    let start = SystemTime::now();
    // Initialize logger
    println!("Starting ULE v1.0.0...");
    if let Err(err) = logger::setup_logger() {
        eprintln!("Failed to initialize logger: {}", err);
        process::exit(1);
    }
    // Creating channel for multithreading communication with main's thread and network's thread
    let (tx, rx) = channel::<bool>();
    // Generate server's address and make it accessible with thread safe
    let address = Arc::new(String::from(format!(
        "{}:{}",
        ADDRESS,
        ADDRESS_PORT.to_string()
    )));
    // Start network in another thread
    thread::spawn({
        let address = address.to_string();
        move || {
            // Start network
            // If failed to start when return error
            if let Err(err) = network_server_start(address, &tx) {
                error!("{}", err);
                tx.send(false);
            }
        }
    });
    // Wait for status from server's network
    if rx.recv().unwrap_or(false) {
        // If Server successful started
        info!("Server started at {}", address);
        // Showing about the full launch and showing the time to start
        {
            let elapsed = start.elapsed().unwrap();
            info!(
                "The server was successfully started in {}",
                if elapsed.as_secs() >= 1 {
                    format!("{}s", elapsed.as_secs())
                } else if elapsed.as_millis() >= 1 {
                    format!("{}ms", elapsed.as_millis())
                } else {
                    format!("{}ns", elapsed.as_nanos())
                }
            );
            drop(elapsed);
        };
    } else {
        // If Failed to start Server
        error!("Failed to start server on {}.", address);
        process::exit(1);
    }
    // Remove channel
    std::mem::drop(rx);
    // Start console input handler(input commands)
    start_input_handler();
}

// Custom error(yes, not std::io:Error)
#[derive(Debug)]
pub struct SimpleError(String, Option<std::io::Error>);

impl Error for SimpleError {}

impl fmt::Display for SimpleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Check is error provided
        if self.1.is_some() {
            write!(f, "{}: {:?}", self.0, self.1)
        } else {
            write!(f, "{}", self.0)
        }
    }
}

// Custom Result with custom Error
pub type SResult<T> = Result<T, SimpleError>;

pub mod chat;
pub mod logger;

Просто импортируем модули чата и логгера публично

mod input;
mod log_lib;

pub use {input::start_input_handler, log_lib::setup_logger};

Тут идёт импорт input.rs и log_lib.rs, а так-же экспорт методов start_input_handler и setup_logger

use crate::Color;
use fern::colors::ColoredLevelConfig;
use std::fs;

// Logger's initialize(fern, color and log)
pub fn setup_logger() -> Result<(), fern::InitError> {
    // Removing latest log if exists
    fs::remove_file("latest.log");
    // Setting colors
    let colors = ColoredLevelConfig::new()
        .info(Color::BrightBlack)
        .warn(Color::Yellow)
        .error(Color::Red)
        .trace(Color::BrightRed);
    // Setting fern
    fern::Dispatch::new()
        // Setting custom format to logging
        .format(move |out, message, record| {
            out.finish(format_args!(
                "{} [{}] {}",
                chrono::Local::now().format("[%m-%d %H:%M:%S]"),
                colors.color(record.level()),
                message
            ))
        })
        // Setting log-level
        .level(log::LevelFilter::Info)
        // Setting target's logger
        .chain(std::io::stdout())
        // Setting log's file
        .chain(fern::log_file("latest.log")?)
        // Applying settings
        .apply()?;
    // If successful setting - returning ok
    Ok(())
}

use crate::network::handler::{handshaking, status_handler};
use crate::network::network_client::ConnectionType::HANDSHAKING;
use crate::network::network_client::NetworkClient;
use ahash::AHashMap;
use mio::net::TcpListener;
use mio::{Events, Interest, Poll, Token};
use std::io;
use std::sync::mpsc::Sender;
use std::sync::Mutex;
use std::time::Duration;

// Declare global variables
lazy_static! {
    // Server need to shut down? (true - yes, needs to shutdown network server).
    pub static ref SHUTDOWN_SERVER: Mutex<bool> = Mutex::new(false);
    // Server's works status.
    pub static ref NET_SERVER_WORKS: Mutex<bool> = Mutex::new(true);
}

// Server's Token(ID)
const SERVER: Token = Token(0);

// Next Token
fn next(current: &mut Token) -> Token {
    let next = current.0;
    current.0 += 1;
    Token(next)
}

// Start a network server
pub fn network_server_start(address: String, tx: &Sender<bool>) -> std::io::Result<()> {
    // Creating Network Pool
    let mut poll = Poll::new()?;
    // Creating Network Events Pool
    let mut events = Events::with_capacity(256);
    // Converting String's address to SocketAddr
    let addr = address.parse().unwrap();
    // Starting a Network Listener
    let mut server = TcpListener::bind(addr)?;
    // Register server's Token
    poll.registry()
        .register(&mut server, SERVER, Interest::READABLE)?;

    // Creating a list of connections
    let mut connections: AHashMap<Token, NetworkClient> = AHashMap::new();
    // Creating a variable with latest token.
    let mut unique_token = Token(SERVER.0 + 1);
    // Send over the channel that the server has been successfully started
    tx.send(true);

    // Network Events getting timeout
    let timeout = Some(Duration::from_millis(10));
    // Infinity loop(while true) to handing events
    loop {
        // Checks whether it is necessary to shutdown the network server
        if *SHUTDOWN_SERVER.lock().unwrap() {
            *NET_SERVER_WORKS.lock().unwrap() = false;
            info!("Network Server Stopped!");
            return Ok(());
        }
        // Getting a events from pool to event's pool with timeout
        poll.poll(&mut events, timeout)?;
        // Handing a events
        for event in events.iter() {
            // Handing event by token
            match event.token() {
                // If it server's event
                // Reading a all incoming connection
                SERVER => loop {
                    // Accepting connection
                    let (mut connection, _) = match server.accept() {
                        // If successful
                        Ok(v) => v,
                        // If not exists incoming connection
                        Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
                            break;
                        }
                        // If failed to get incoming connection
                        Err(e) => {
                            return Err(e);
                        }
                    };

                    // Generating new token for this connection
                    let token = next(&mut unique_token);
                    // Registering connection with token
                    poll.registry().register(
                        &mut connection,
                        token,
                        Interest::READABLE.add(Interest::WRITABLE),
                    )?;
                    // Pushing connection into connection's list
                    connections.insert(
                        token,
                        NetworkClient {
                            stream: connection,
                            conn_type: HANDSHAKING,
                        },
                    );
                },
                // Handing event from client
                token => {
                    // Handing event by connection's stage
                    let done = if let Some(connection) = connections.get_mut(&token) {
                        let m = match &connection.conn_type {
                            HANDSHAKING => handshaking,
                            _ => status_handler,
                        };
                        // Trying to handing
                        m(connection, &event).unwrap_or(false)
                    } else {
                        false
                    };
                    // If needs to close connection - removing from list, unregister and close connection's stream
                    if done {
                        if let Some(mut connection) = connections.remove(&token) {
                            poll.registry().deregister(&mut connection.stream)?;
                            connections.remove(&token);
                        }
                    }
                }
            }
        }
    }
}

Да, уже целых 125 строчек, но это ещё мало

use crate::{SResult, SimpleError};

/// Reader [Vec] of bytes
pub trait PacketReader {
    // 1-Byte
    fn get_u8(&mut self) -> u8;
    fn get_i8(&mut self) -> i8;
    // 2-Byte
    fn get_u16(&mut self) -> u16;
    fn get_i16(&mut self) -> i16;
    // 4-Byte
    fn get_varint(&mut self) -> SResult<i32>;
    // 8-Byte
    fn get_i64(&mut self) -> i64;
    // Another
    fn get_string(&mut self) -> SResult<String>;
    fn read_base(&mut self) -> SResult<(i32, i32)>;
}

// Apply reader to Vec
impl PacketReader for Vec<u8> {
    // Read a single byte as u8 ( 8-Bit Unsigned Integer )
    fn get_u8(&mut self) -> u8 {
        self.remove(0)
    }

    // Read a single byte as i8 ( 8-Bit Integer )
    fn get_i8(&mut self) -> i8 {
        self.remove(1) as i8
    }

    // Read a two bytes as u16 ( 16-Bit Unsigned Integer )
    fn get_u16(&mut self) -> u16 {
        u16::from_be_bytes([self.get_u8(), self.get_u8()])
    }

    // Read a two bytes as i16 ( 16-Bit Integer )
    fn get_i16(&mut self) -> i16 {
        i16::from_be_bytes([self.get_u8(), self.get_u8()])
    }

    // Read a VarInt ( Dynamic-length 32-Bit Integer )
    fn get_varint(&mut self) -> SResult<i32> {
        // Result variable
        let mut ans = 0;
        // Read up to 4 bytes
        for i in 0..4 {
            // Read one byte
            let buf = self.get_u8();
            // Calculate res with bit moving and another
            ans |= ((buf & 0b0111_1111) as i32) << 7 * i;
            // If it's limit when stop reading
            if buf & 0b1000_0000 == 0 {
                break;
            }
        }
        // Return result as successful
        Ok(ans)
    }

    // Read a Long ( 64-Bit Integer )
    fn get_i64(&mut self) -> i64 {
        // Yes, read 8 bytes
        i64::from_be_bytes([
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
            self.get_u8(),
        ])
    }

    // Read a String ( VarInt as len; bytes[::len] )
    fn get_string(&mut self) -> SResult<String> {
        // Getting string-length
        let len = self.get_varint()?;
        // Create String's bytes buffer
        let mut buf = Vec::new();
        // Reading Bytes
        for _ in 0..len {
            buf.push(self.get_u8())
        }
        // Convert Bytes to UTF8 String
        match String::from_utf8(buf) {
            Ok(v) => Ok(v),
            Err(_) => Err(SimpleError(String::from("Failed to parse chars"), None)),
        }
    }
    // Read first two VarInt(Packet's length and id)
    fn read_base(&mut self) -> SResult<(i32, i32)> {
        let len = self.get_varint()?;
        let pid = self.get_varint()?;
        Ok((len, pid))
    }
}

Тут мы можем наглядно увидеть чтение VarInt, String, Long и другое, что пока надо было при написании ядра.

/// Writer [Vec] of bytes
pub trait PacketWriter {
    // 1-Byte
    fn write_u8(&mut self, value: u8);
    fn write_i8(&mut self, value: i8);
    // 2-Byte
    fn write_u16(&mut self, value: u16);
    fn write_i16(&mut self, value: i16);
    // 4-Byte
    fn write_varint(&mut self, value: i32);
    // 8-Byte
    fn write_i64(&mut self, value: i64);
    // Another
    fn write_vec_bytes(&mut self, bytes: Vec<u8>);
    fn write_string(&mut self, value: String);
    fn create_packet(&mut self, pid: i32) -> Vec<u8>;
}

impl PacketWriter for Vec<u8> {
    // Writing byte
    fn write_u8(&mut self, value: u8) {
        self.push(value);
    }

    // Writing byte
    fn write_i8(&mut self, value: i8) {
        self.push(value as u8)
    }

    // Writing 2-byte unsigned integer
    fn write_u16(&mut self, value: u16) {
        self.extend_from_slice(&value.to_be_bytes());
    }

    // Writing 2-byte unsigned integer
    fn write_i16(&mut self, value: i16) {
        self.extend_from_slice(&value.to_be_bytes());
    }

    // Writing bytes as VarInt
    fn write_varint(&mut self, mut value: i32) {
        // Bytes buffer
        let mut buf = vec![0u8; 1];
        // Byte's length
        let mut n = 0;
        // Converts value to bytes
        loop {
            // Break if it's limit
            if value <= 127 || n >= 8 {
                break;
            }
            // Pushing a byte to buffer
            buf.insert(n, (0x80 | (value & 0x7F)) as u8);
            // Moving value's bits on 7
            value >>= 7;
            value -= 1;
            n += 1;
        }
        // Pushing byte, because it lower that 256(<256)
        buf.insert(n, value as u8);
        n += 1;
        // Pushing converted bytes into byte's buffer
        self.extend_from_slice(&buf.as_slice()[..n])
    }

    // Writing Long ( 64-Bit Integer )
    fn write_i64(&mut self, value: i64) {
        self.extend_from_slice(value.to_be_bytes().as_slice())
    }

    // Alias of extend_from_slice, but works with Vec, not Slice
    fn write_vec_bytes(&mut self, mut bytes: Vec<u8>) {
        self.append(&mut bytes);
    }

    // Write String (VarInt as len and string's bytes)
    fn write_string(&mut self, value: String) {
        // Getting String as Bytes
        let bytes = value.as_bytes();
        // Writing to buffer a length as VarInt
        self.write_varint(bytes.len() as i32);
        // Writing to buffer a string's bytes
        self.extend_from_slice(bytes);
    }

    // Packet's base builder
    fn create_packet(&mut self, pid: i32) -> Vec<u8> {
        // Creating empty packet's buffer
        let mut packet = Vec::new();
        // Creating length's bytes buffer and fill it as VarInt
        let mut len_bytes: Vec<u8> = Vec::new();
        len_bytes.write_varint(pid);
        // Writing full packet's length(content + length's bytes)
        packet.write_varint((self.len() + len_bytes.len()) as i32);
        // Writing length bytes
        packet.extend_from_slice(len_bytes.as_slice());
        // Drop(Free) length bytes buffer
        drop(len_bytes);
        // Writing some packet's content
        packet.extend_from_slice(self.as_slice());
        // Returning result
        packet
    }
}

Запись к буферам выглядит в разы интересней из-за больших требований к стандарту протокола MineCraft.

pub fn read_handshake_packet(client: &mut NetworkClient) -> SResult<(u32, String, u16, u32)> {
    // Read bytes from client
    let (ok, p, err) = match client.read() {
        Ok((ok, p)) => (ok, Some(p), None),
        Err(err) => (false, None, Some(err)),
    };
    // If failed to read when...
    if !ok || err.is_some() {
        return Err(SimpleError(
            String::from("Failed to read packet"),
            if err.is_some() { err.unwrap().1 } else { None },
        ));
    }
    // Reading packet
    let mut p: Vec<u8> = p.unwrap();
    // Try to read Length and PacketID from packet(on handshaking stage only 0x00)
    p.read_base()?;
    // Reading version, address and etc.
    let ver = p.get_varint()? as u32;
    let address = p.get_string()?;
    let port = p.get_u16();
    let next_state = p.get_varint()? as u32;
    // States can be only 1 - status, 2 - play
    if next_state >= 3 {
        return Err(SimpleError(String::from("Invalid client"), None));
    }
    // Returning results
    Ok((ver, address, port, next_state))
}

Мы читаем пакет и при ошибке возращаем её, а если получилось прочитать полностью, то и возращаем результаты чтения.

// Structs for status MOTD response
#[derive(Debug, Serialize)]
pub struct ListPingResponse {
    pub version: ListPingResponseVersion,
    pub players: ListPingResponsePlayers,
    pub description: ChatMessage,
}

#[derive(Debug, Serialize)]
pub struct ListPingResponseVersion {
    pub name: String,
    pub protocol: u32,
}

#[derive(Debug, Serialize)]
pub struct ListPingResponsePlayers {
    pub max: u32,
    pub online: u32,
    pub sample: Vec<ListPingResponsePlayerSample>,
}

#[derive(Debug, Serialize)]
pub struct ListPingResponsePlayerSample {
    pub name: String,
    pub id: String,
}
/// Build packet's bytes as result
pub fn create_server_list_ping_response() -> Vec<u8> {
    // Initialize empty byte's vector
    let mut bytes = Vec::new();
    // Generating String and convert to bytes.
    // String generated as JSON by serde and serde_json libraries
    bytes.write_string(
        serde_json::to_string(&ListPingResponse {
            version: ListPingResponseVersion {
                name: String::from("ULE"),
                protocol: PROTOCOL_VERSION,
            },
            players: ListPingResponsePlayers {
                max: 10,
                online: 0,
                sample: vec![],
            },
            // Some clients can read colors and so on without convert into JSON
            description: ChatMessage::str("&a&lHello!"),
        })
        .unwrap(),
    );
    // Build completed packet. Server List Ping - PacketID is 0x00
    bytes.create_packet(0x00)
}

Для него мы сначала используем информацию о том как должен выглядеть JSON ответа и для ответа мы делаем пустой буффер, записываем байты переведённой сструктуры в JSON и генерируем пакет с айди 0x00. Для серелизации используем serde и serde_json.