Added packets folder for the packet-service until I automate generation at build time

packet-service/src/packets/cli_accept_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAcceptReq {}
+
+impl PacketPayload for CliAcceptReq {}
+
+impl Encode for CliAcceptReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAcceptReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_alive.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlive {}
+
+impl PacketPayload for CliAlive {}
+
+impl Encode for CliAlive {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlive {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_allied_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlliedChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliAlliedChat {}
+
+impl Encode for CliAlliedChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlliedChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_allied_shout_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlliedShoutChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliAlliedShoutChat {}
+
+impl Encode for CliAlliedShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlliedShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_appraisal_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAppraisalReq {
+    pub(crate) index: u16,
+}
+
+impl PacketPayload for CliAppraisalReq {}
+
+impl Encode for CliAppraisalReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAppraisalReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        Ok(Self { index })
+    }
+}

packet-service/src/packets/cli_attack.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAttack {
+    pub(crate) target_id: u16,
+}
+
+impl PacketPayload for CliAttack {}
+
+impl Encode for CliAttack {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAttack {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        Ok(Self { target_id })
+    }
+}

packet-service/src/packets/cli_bank_list_req.rs

@@ -0,0 +1,61 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankListRequest {
+    Open = 0,
+    ChangePassword = 17,
+}
+
+impl Encode for BankListRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankListRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankListRequest::Open),
+            17 => Ok(BankListRequest::ChangePassword),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankListRequest: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankListReq {
+    pub(crate) request: BankListRequest,
+    pub(crate) password: NullTerminatedString,
+}
+
+impl PacketPayload for CliBankListReq {}
+
+impl Encode for CliBankListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.request.encode(encoder)?;
+        self.password.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let request = BankListRequest::decode(decoder)?;
+        let password = NullTerminatedString::decode(decoder)?;
+        Ok(Self { request, password })
+    }
+}

packet-service/src/packets/cli_bank_move_item.rs

@@ -0,0 +1,164 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankMoveMode {
+    InventoryToBank = 0,
+    BankToInventory = 1,
+}
+
+impl Encode for BankMoveMode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankMoveMode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankMoveMode::InventoryToBank),
+            1 => Ok(BankMoveMode::BankToInventory),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankMoveMode: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankMoveItem {
+    pub(crate) mode: BankMoveMode,
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+    pub(crate) use_special_tab: u8,
+}
+
+impl PacketPayload for CliBankMoveItem {}
+
+impl Encode for CliBankMoveItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.mode.encode(encoder)?;
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.use_special_tab.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankMoveItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mode = BankMoveMode::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let use_special_tab = u8::decode(decoder)?;
+        Ok(Self {
+            mode,
+            index,
+            item,
+            use_special_tab,
+        })
+    }
+}

packet-service/src/packets/cli_bank_move_money.rs

@@ -0,0 +1,61 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankMoveMode {
+    InventoryToBank = 16,
+    BankToInventory = 17,
+}
+
+impl Encode for BankMoveMode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankMoveMode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            16 => Ok(BankMoveMode::InventoryToBank),
+            17 => Ok(BankMoveMode::BankToInventory),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankMoveMode: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankMoveMoney {
+    pub(crate) mode: BankMoveMode,
+    pub(crate) amount: i64,
+}
+
+impl PacketPayload for CliBankMoveMoney {}
+
+impl Encode for CliBankMoveMoney {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.mode.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankMoveMoney {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mode = BankMoveMode::decode(decoder)?;
+        let amount = i64::decode(decoder)?;
+        Ok(Self { mode, amount })
+    }
+}

packet-service/src/packets/cli_change_char_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChangeCharReq {}
+
+impl PacketPayload for CliChangeCharReq {}
+
+impl Encode for CliChangeCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChangeCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_change_map_req.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChangeMapReq {
+    pub(crate) weight_rate: u8,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliChangeMapReq {}
+
+impl Encode for CliChangeMapReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.weight_rate.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChangeMapReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let weight_rate = u8::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { weight_rate, z })
+    }
+}

packet-service/src/packets/cli_channel_list_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChannelListReq {
+    pub(crate) server_id: u32,
+}
+
+impl PacketPayload for CliChannelListReq {}
+
+impl Encode for CliChannelListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.server_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChannelListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let server_id = u32::decode(decoder)?;
+        Ok(Self { server_id })
+    }
+}

packet-service/src/packets/cli_char_list_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCharListReq {}
+
+impl PacketPayload for CliCharListReq {}
+
+impl Encode for CliCharListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCharListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_chatroom.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChatroom {}
+
+impl PacketPayload for CliChatroom {}
+
+impl Encode for CliChatroom {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChatroom {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_chatroom_message.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChatroomMessage {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliChatroomMessage {}
+
+impl Encode for CliChatroomMessage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChatroomMessage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_clan_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliClanChat {}
+
+impl Encode for CliClanChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_clan_command.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanCommand {}
+
+impl PacketPayload for CliClanCommand {}
+
+impl Encode for CliClanCommand {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanCommand {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_clan_icon_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconReq {
+    pub(crate) id: u32,
+}
+
+impl PacketPayload for CliClanIconReq {}
+
+impl Encode for CliClanIconReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u32::decode(decoder)?;
+        Ok(Self { id })
+    }
+}

packet-service/src/packets/cli_clan_icon_set.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconSet {
+    pub(crate) crc: u16,
+    pub(crate) data: Vec<u8>,
+}
+
+impl PacketPayload for CliClanIconSet {}
+
+impl Encode for CliClanIconSet {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.crc.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconSet {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let crc = u16::decode(decoder)?;
+        let data = Vec::decode(decoder)?;
+        Ok(Self { crc, data })
+    }
+}

packet-service/src/packets/cli_clan_icon_timestamp.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconTimestamp {}
+
+impl PacketPayload for CliClanIconTimestamp {}
+
+impl Encode for CliClanIconTimestamp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconTimestamp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_craft_enhance_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCraftEnhanceReq {}
+
+impl PacketPayload for CliCraftEnhanceReq {}
+
+impl Encode for CliCraftEnhanceReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftEnhanceReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_craft_req.rs

@@ -0,0 +1,50 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCraftReq {
+    pub(crate) slot: u8,
+    pub(crate) type_: i8,
+    pub(crate) id: i8,
+    pub(crate) material_slots: [i16; 4],
+}
+
+impl PacketPayload for CliCraftReq {}
+
+impl Encode for CliCraftReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        for value in &self.material_slots {
+            value.encode(encoder)?;
+        }
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let type_ = i8::decode(decoder)?;
+        let id = i8::decode(decoder)?;
+        let mut material_slots = [0i16; 4];
+        for value in &mut material_slots {
+            *value = i16::decode(decoder)?;
+        }
+        Ok(Self {
+            slot,
+            type_,
+            id,
+            material_slots,
+        })
+    }
+}

packet-service/src/packets/cli_craft_status.rs

@@ -0,0 +1,72 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum CraftStatus {
+    CraftStart = 0,
+    CraftSuccess = 1,
+    CraftFail = 2,
+    UpgradeStart = 3,
+    UpgradeSuccess = 4,
+    UpgradeFail = 5,
+}
+
+impl Encode for CraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for CraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(CraftStatus::CraftStart),
+            1 => Ok(CraftStatus::CraftSuccess),
+            2 => Ok(CraftStatus::CraftFail),
+            3 => Ok(CraftStatus::UpgradeStart),
+            4 => Ok(CraftStatus::UpgradeSuccess),
+            5 => Ok(CraftStatus::UpgradeFail),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for CraftStatus: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliCraftStatus {
+    pub(crate) stats: CraftStatus,
+    pub(crate) type_: i8,
+    pub(crate) id: i16,
+}
+
+impl PacketPayload for CliCraftStatus {}
+
+impl Encode for CliCraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.stats.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let stats = CraftStatus::decode(decoder)?;
+        let type_ = i8::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        Ok(Self { stats, type_, id })
+    }
+}

packet-service/src/packets/cli_create_char_req.rs

@@ -0,0 +1,57 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCreateCharReq {
+    pub(crate) race: u8,
+    pub(crate) stone: u8,
+    pub(crate) hair: u8,
+    pub(crate) face: u8,
+    pub(crate) weapon: u8,
+    pub(crate) zone: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliCreateCharReq {}
+
+impl Encode for CliCreateCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.race.encode(encoder)?;
+        self.stone.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.weapon.encode(encoder)?;
+        self.zone.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCreateCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let race = u8::decode(decoder)?;
+        let stone = u8::decode(decoder)?;
+        let hair = u8::decode(decoder)?;
+        let face = u8::decode(decoder)?;
+        let weapon = u8::decode(decoder)?;
+        let zone = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            race,
+            stone,
+            hair,
+            face,
+            weapon,
+            zone,
+            name,
+        })
+    }
+}

packet-service/src/packets/cli_damage.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDamage {
+    pub(crate) target_id: u16,
+    pub(crate) random_id: u16,
+}
+
+impl PacketPayload for CliDamage {}
+
+impl Encode for CliDamage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        self.random_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDamage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        let random_id = u16::decode(decoder)?;
+        Ok(Self { target_id, random_id })
+    }
+}

packet-service/src/packets/cli_delete_char_req.rs

@@ -0,0 +1,41 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDeleteCharReq {
+    pub(crate) char_id: u8,
+    pub(crate) is_delete: u8,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliDeleteCharReq {}
+
+impl Encode for CliDeleteCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.is_delete.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDeleteCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u8::decode(decoder)?;
+        let is_delete = u8::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            is_delete,
+            name,
+        })
+    }
+}

packet-service/src/packets/cli_drop_item.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDropItem {
+    pub(crate) index: u8,
+    pub(crate) quantity: u32,
+}
+
+impl PacketPayload for CliDropItem {}
+
+impl Encode for CliDropItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.quantity.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDropItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let quantity = u32::decode(decoder)?;
+        Ok(Self { index, quantity })
+    }
+}

packet-service/src/packets/cli_equip_item.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliEquipItem {
+    pub(crate) slot_to: i16,
+    pub(crate) slot_from: i16,
+}
+
+impl PacketPayload for CliEquipItem {}
+
+impl Encode for CliEquipItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot_to.encode(encoder)?;
+        self.slot_from.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot_to = i16::decode(decoder)?;
+        let slot_from = i16::decode(decoder)?;
+        Ok(Self { slot_to, slot_from })
+    }
+}

packet-service/src/packets/cli_equip_item_ride.rs

@@ -0,0 +1,67 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPositionRide {
+    Body = 0,
+    Engine = 1,
+    Leg = 2,
+    Ability = 3,
+    Arm = 4,
+}
+
+impl Encode for EquippedPositionRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPositionRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPositionRide::Body),
+            1 => Ok(EquippedPositionRide::Engine),
+            2 => Ok(EquippedPositionRide::Leg),
+            3 => Ok(EquippedPositionRide::Ability),
+            4 => Ok(EquippedPositionRide::Arm),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPositionRide: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliEquipItemRide {
+    pub(crate) slot: EquippedPositionRide,
+    pub(crate) index: u16,
+}
+
+impl PacketPayload for CliEquipItemRide {}
+
+impl Encode for CliEquipItemRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipItemRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = EquippedPositionRide::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        Ok(Self { slot, index })
+    }
+}

packet-service/src/packets/cli_equip_projectile.rs

@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct ProjectileTypeAndIndex {
+    pub(crate) type_: u8,
+    pub(crate) index: u16,
+}
+
+impl Encode for ProjectileTypeAndIndex {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ProjectileTypeAndIndex {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        Ok(Self { type_, index })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliEquipProjectile {
+    pub(crate) projectile: ProjectileTypeAndIndex,
+}
+
+impl PacketPayload for CliEquipProjectile {}
+
+impl Encode for CliEquipProjectile {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.projectile.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipProjectile {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let projectile = ProjectileTypeAndIndex::decode(decoder)?;
+        Ok(Self { projectile })
+    }
+}

packet-service/src/packets/cli_hotbar_set_icon_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliHotbarSetIconReq {}
+
+impl PacketPayload for CliHotbarSetIconReq {}
+
+impl Encode for CliHotbarSetIconReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliHotbarSetIconReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_hp_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliHpReq {
+    pub(crate) target_id: u16,
+}
+
+impl PacketPayload for CliHpReq {}
+
+impl Encode for CliHpReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliHpReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        Ok(Self { target_id })
+    }
+}

packet-service/src/packets/cli_join_server_req.rs

@@ -0,0 +1,68 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct Password {
+    pub(crate) password: String,
+}
+
+impl Encode for Password {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        let bytes = self.password.as_bytes();
+        let fixed_length = 64;
+        if bytes.len() > fixed_length {
+            return Err(bincode::error::EncodeError::OtherString(format!(
+                "password length exceeds fixed size: {} > {}",
+                bytes.len(),
+                fixed_length
+            )));
+        }
+        encoder.writer().write(bytes)?;
+        encoder.writer().write(&vec![0; fixed_length - bytes.len()])?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Password {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mut buffer = vec![0u8; 64];
+        decoder.reader().read(&mut buffer)?;
+        let password = String::from_utf8(buffer)
+            .map_err(|e| DecodeError::OtherString(format!("Invalid UTF-8: {}", e)))?
+            .trim_end_matches('\0')
+            .to_string();
+        Ok(Self { password })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliJoinServerReq {
+    pub(crate) session_id: u32,
+    pub(crate) password: Password,
+}
+
+impl PacketPayload for CliJoinServerReq {}
+
+impl Encode for CliJoinServerReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.session_id.encode(encoder)?;
+        self.password.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliJoinServerReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let session_id = u32::decode(decoder)?;
+        let password = Password::decode(decoder)?;
+        Ok(Self { session_id, password })
+    }
+}

packet-service/src/packets/cli_join_server_token_req.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliJoinServerTokenReq {
+    pub(crate) session_id: u32,
+    pub(crate) token: NullTerminatedString,
+}
+
+impl PacketPayload for CliJoinServerTokenReq {}
+
+impl Encode for CliJoinServerTokenReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.session_id.encode(encoder)?;
+        self.token.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliJoinServerTokenReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let session_id = u32::decode(decoder)?;
+        let token = NullTerminatedString::decode(decoder)?;
+        Ok(Self { session_id, token })
+    }
+}

packet-service/src/packets/cli_login_req.rs

@@ -0,0 +1,68 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct Password {
+    pub(crate) password: String,
+}
+
+impl Encode for Password {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        let bytes = self.password.as_bytes();
+        let fixed_length = 64;
+        if bytes.len() > fixed_length {
+            return Err(bincode::error::EncodeError::OtherString(format!(
+                "password length exceeds fixed size: {} > {}",
+                bytes.len(),
+                fixed_length
+            )));
+        }
+        encoder.writer().write(bytes)?;
+        encoder.writer().write(&vec![0; fixed_length - bytes.len()])?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Password {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mut buffer = vec![0u8; 64];
+        decoder.reader().read(&mut buffer)?;
+        let password = String::from_utf8(buffer)
+            .map_err(|e| DecodeError::OtherString(format!("Invalid UTF-8: {}", e)))?
+            .trim_end_matches('\0')
+            .to_string();
+        Ok(Self { password })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliLoginReq {
+    pub(crate) password: Password,
+    pub(crate) username: NullTerminatedString,
+}
+
+impl PacketPayload for CliLoginReq {}
+
+impl Encode for CliLoginReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.password.encode(encoder)?;
+        self.username.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLoginReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let password = Password::decode(decoder)?;
+        let username = NullTerminatedString::decode(decoder)?;
+        Ok(Self { password, username })
+    }
+}

packet-service/src/packets/cli_login_token_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliLoginTokenReq {
+    pub(crate) token: NullTerminatedString,
+}
+
+impl PacketPayload for CliLoginTokenReq {}
+
+impl Encode for CliLoginTokenReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.token.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLoginTokenReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let token = NullTerminatedString::decode(decoder)?;
+        Ok(Self { token })
+    }
+}

packet-service/src/packets/cli_logout_req.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliLogoutReq {}
+
+impl PacketPayload for CliLogoutReq {}
+
+impl Encode for CliLogoutReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLogoutReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_memo.rs

@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MemoType {
+    RequestContent = 0,
+    Send = 1,
+    ReceivedCount = 2,
+}
+
+impl Encode for MemoType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MemoType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MemoType::RequestContent),
+            1 => Ok(MemoType::Send),
+            2 => Ok(MemoType::ReceivedCount),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MemoType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliMemo {
+    pub(crate) type_: MemoType,
+    pub(crate) target: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliMemo {}
+
+impl Encode for CliMemo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMemo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = MemoType::decode(decoder)?;
+        let target = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { type_, target, message })
+    }
+}

packet-service/src/packets/cli_messenger.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMessenger {}
+
+impl PacketPayload for CliMessenger {}
+
+impl Encode for CliMessenger {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMessenger {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_messenger_chat.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMessengerChat {
+    pub(crate) tag: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliMessengerChat {}
+
+impl Encode for CliMessengerChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.tag.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMessengerChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let tag = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { tag, message })
+    }
+}

packet-service/src/packets/cli_mouse_cmd.rs

@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMouseCmd {
+    pub(crate) target_id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliMouseCmd {}
+
+impl Encode for CliMouseCmd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMouseCmd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { target_id, x, y, z })
+    }
+}

packet-service/src/packets/cli_normal_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliNormalChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliNormalChat {}
+
+impl Encode for CliNormalChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliNormalChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_party_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliPartyChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliPartyChat {}
+
+impl Encode for CliPartyChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_party_reply.rs

@@ -0,0 +1,85 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReplyType {
+    NotFound = 0,
+    Busy = 1,
+    AcceptCreate = 2,
+    AcceptJoin = 3,
+    RejectJoin = 4,
+    Destroy = 5,
+    Full = 6,
+    InvalidLevel = 7,
+    ChangeOwner = 8,
+    ChangeOwnerAndLeave = 9,
+    NoPremium = 10,
+    Bad = 128,
+    Leave = 129,
+    Rejoin = 130,
+}
+
+impl Encode for PartyReplyType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReplyType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReplyType::NotFound),
+            1 => Ok(PartyReplyType::Busy),
+            2 => Ok(PartyReplyType::AcceptCreate),
+            3 => Ok(PartyReplyType::AcceptJoin),
+            4 => Ok(PartyReplyType::RejectJoin),
+            5 => Ok(PartyReplyType::Destroy),
+            6 => Ok(PartyReplyType::Full),
+            7 => Ok(PartyReplyType::InvalidLevel),
+            8 => Ok(PartyReplyType::ChangeOwner),
+            9 => Ok(PartyReplyType::ChangeOwnerAndLeave),
+            10 => Ok(PartyReplyType::NoPremium),
+            128 => Ok(PartyReplyType::Bad),
+            129 => Ok(PartyReplyType::Leave),
+            130 => Ok(PartyReplyType::Rejoin),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReplyType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyReply {
+    pub(crate) type_: PartyReplyType,
+    pub(crate) target: u32,
+}
+
+impl PacketPayload for CliPartyReply {}
+
+impl Encode for CliPartyReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReplyType::decode(decoder)?;
+        let target = u32::decode(decoder)?;
+        Ok(Self { type_, target })
+    }
+}

packet-service/src/packets/cli_party_req.rs

@@ -0,0 +1,67 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReqType {
+    Create = 0,
+    Join = 1,
+    Leave = 2,
+    ChangeOwner = 3,
+    Ban = 129,
+}
+
+impl Encode for PartyReqType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReqType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReqType::Create),
+            1 => Ok(PartyReqType::Join),
+            2 => Ok(PartyReqType::Leave),
+            3 => Ok(PartyReqType::ChangeOwner),
+            129 => Ok(PartyReqType::Ban),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReqType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyReq {
+    pub(crate) type_: PartyReqType,
+    pub(crate) target: u16,
+}
+
+impl PacketPayload for CliPartyReq {}
+
+impl Encode for CliPartyReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReqType::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        Ok(Self { type_, target })
+    }
+}

packet-service/src/packets/cli_party_rule.rs

@@ -0,0 +1,58 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyRule {
+    ExpPerPlayer = 1,
+    ItemInOrder = 128,
+}
+
+impl Encode for PartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(PartyRule::ExpPerPlayer),
+            128 => Ok(PartyRule::ItemInOrder),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyRule: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyRule {
+    pub(crate) rule: PartyRule,
+}
+
+impl PacketPayload for CliPartyRule {}
+
+impl Encode for CliPartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.rule.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let rule = PartyRule::decode(decoder)?;
+        Ok(Self { rule })
+    }
+}

packet-service/src/packets/cli_pickup_item_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliPickupItemReq {
+    pub(crate) item_id: u16,
+}
+
+impl PacketPayload for CliPickupItemReq {}
+
+impl Encode for CliPickupItemReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPickupItemReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let item_id = u16::decode(decoder)?;
+        Ok(Self { item_id })
+    }
+}

packet-service/src/packets/cli_quest_data_req.rs

@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum QuestDataRequestType {
+    Add = 0,
+    Remove = 1,
+    Trigger = 2,
+}
+
+impl Encode for QuestDataRequestType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for QuestDataRequestType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(QuestDataRequestType::Add),
+            1 => Ok(QuestDataRequestType::Remove),
+            2 => Ok(QuestDataRequestType::Trigger),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for QuestDataRequestType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliQuestDataReq {
+    pub(crate) type_: QuestDataRequestType,
+    pub(crate) slot: u8,
+    pub(crate) id: i32,
+}
+
+impl PacketPayload for CliQuestDataReq {}
+
+impl Encode for CliQuestDataReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliQuestDataReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = QuestDataRequestType::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        let id = i32::decode(decoder)?;
+        Ok(Self { type_, slot, id })
+    }
+}

packet-service/src/packets/cli_repair_npc.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliRepairNpc {
+    pub(crate) npc_id: u16,
+    pub(crate) target_index: u16,
+}
+
+impl PacketPayload for CliRepairNpc {}
+
+impl Encode for CliRepairNpc {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.npc_id.encode(encoder)?;
+        self.target_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRepairNpc {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let npc_id = u16::decode(decoder)?;
+        let target_index = u16::decode(decoder)?;
+        Ok(Self { npc_id, target_index })
+    }
+}

packet-service/src/packets/cli_repair_use_item.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliRepairUseItem {
+    pub(crate) index: u16,
+    pub(crate) target_index: u16,
+}
+
+impl PacketPayload for CliRepairUseItem {}
+
+impl Encode for CliRepairUseItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.target_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRepairUseItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let target_index = u16::decode(decoder)?;
+        Ok(Self { index, target_index })
+    }
+}

packet-service/src/packets/cli_revive_req.rs

@@ -0,0 +1,62 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ReviveRequest {
+    RevivePosition = 1,
+    SavePosition = 2,
+    StartPosition = 3,
+    CurrentPosition = 4,
+}
+
+impl Encode for ReviveRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ReviveRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(ReviveRequest::RevivePosition),
+            2 => Ok(ReviveRequest::SavePosition),
+            3 => Ok(ReviveRequest::StartPosition),
+            4 => Ok(ReviveRequest::CurrentPosition),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ReviveRequest: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliReviveReq {
+    pub(crate) revive_type: ReviveRequest,
+}
+
+impl PacketPayload for CliReviveReq {}
+
+impl Encode for CliReviveReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.revive_type.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliReviveReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let revive_type = ReviveRequest::decode(decoder)?;
+        Ok(Self { revive_type })
+    }
+}

packet-service/src/packets/cli_revive_set_pos.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliReviveSetPos {}
+
+impl PacketPayload for CliReviveSetPos {}
+
+impl Encode for CliReviveSetPos {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliReviveSetPos {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_ride_request.rs

@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum RideAction {
+    Request = 0,
+    Accept = 1,
+    Refuse = 2,
+    OwnerNotFound = 3,
+    GuestNotFound = 4,
+}
+
+impl Encode for RideAction {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for RideAction {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(RideAction::Request),
+            1 => Ok(RideAction::Accept),
+            2 => Ok(RideAction::Refuse),
+            3 => Ok(RideAction::OwnerNotFound),
+            4 => Ok(RideAction::GuestNotFound),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for RideAction: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliRideRequest {
+    pub(crate) action: RideAction,
+    pub(crate) owner: u16,
+    pub(crate) guest: u32,
+}
+
+impl PacketPayload for CliRideRequest {}
+
+impl Encode for CliRideRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.action.encode(encoder)?;
+        self.owner.encode(encoder)?;
+        self.guest.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRideRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let action = RideAction::decode(decoder)?;
+        let owner = u16::decode(decoder)?;
+        let guest = u32::decode(decoder)?;
+        Ok(Self { action, owner, guest })
+    }
+}

packet-service/src/packets/cli_screen_shot_time_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliScreenShotTimeReq {
+    pub(crate) count: u16,
+}
+
+impl PacketPayload for CliScreenShotTimeReq {}
+
+impl Encode for CliScreenShotTimeReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliScreenShotTimeReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let count = u16::decode(decoder)?;
+        Ok(Self { count })
+    }
+}

packet-service/src/packets/cli_select_char_req.rs

@@ -0,0 +1,45 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSelectCharReq {
+    pub(crate) char_id: u8,
+    pub(crate) run_mode: u8,
+    pub(crate) ride_mode: u8,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliSelectCharReq {}
+
+impl Encode for CliSelectCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.run_mode.encode(encoder)?;
+        self.ride_mode.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSelectCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u8::decode(decoder)?;
+        let run_mode = u8::decode(decoder)?;
+        let ride_mode = u8::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            run_mode,
+            ride_mode,
+            name,
+        })
+    }
+}

packet-service/src/packets/cli_set_animation.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetAnimation {
+    pub(crate) id: u16,
+    pub(crate) value: u16,
+}
+
+impl PacketPayload for CliSetAnimation {}
+
+impl Encode for CliSetAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let value = u16::decode(decoder)?;
+        Ok(Self { id, value })
+    }
+}

packet-service/src/packets/cli_set_position.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetPosition {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliSetPosition {}
+
+impl Encode for CliSetPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { x, y })
+    }
+}

packet-service/src/packets/cli_set_server_var_req.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetServerVarReq {
+    pub(crate) type_: u8,
+    pub(crate) value: u32,
+}
+
+impl PacketPayload for CliSetServerVarReq {}
+
+impl Encode for CliSetServerVarReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetServerVarReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let value = u32::decode(decoder)?;
+        Ok(Self { type_, value })
+    }
+}

packet-service/src/packets/cli_set_weight_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetWeightReq {
+    pub(crate) weight: u8,
+}
+
+impl PacketPayload for CliSetWeightReq {}
+
+impl Encode for CliSetWeightReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.weight.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetWeightReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let weight = u8::decode(decoder)?;
+        Ok(Self { weight })
+    }
+}

packet-service/src/packets/cli_shop_buy_req.rs

@@ -0,0 +1,151 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopBuyItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopBuyItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuyItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopBuyReq {
+    pub(crate) id: u16,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopBuyItem>,
+}
+
+impl PacketPayload for CliShopBuyReq {}
+
+impl Encode for CliShopBuyReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopBuyReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { id, count, items })
+    }
+}

packet-service/src/packets/cli_shop_buysell_reply.rs

@@ -0,0 +1,196 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ShopBuySellResult {
+    Null = 0,
+    SoldOut = 1,
+    OverSold = 2,
+    BuyPartial = 3,
+    BuyAll = 4,
+    SellPartial = 5,
+    SellAll = 6,
+}
+
+impl Encode for ShopBuySellResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuySellResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(ShopBuySellResult::Null),
+            1 => Ok(ShopBuySellResult::SoldOut),
+            2 => Ok(ShopBuySellResult::OverSold),
+            3 => Ok(ShopBuySellResult::BuyPartial),
+            4 => Ok(ShopBuySellResult::BuyAll),
+            5 => Ok(ShopBuySellResult::SellPartial),
+            6 => Ok(ShopBuySellResult::SellAll),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ShopBuySellResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopBuySellItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopBuySellItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuySellItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopBuysellReply {
+    pub(crate) id: u16,
+    pub(crate) result: ShopBuySellResult,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopBuySellItem>,
+}
+
+impl PacketPayload for CliShopBuysellReply {}
+
+impl Encode for CliShopBuysellReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.result.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopBuysellReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let result = ShopBuySellResult::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self {
+            id,
+            result,
+            count,
+            items,
+        })
+    }
+}

packet-service/src/packets/cli_shop_close.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShopClose {}
+
+impl PacketPayload for CliShopClose {}
+
+impl Encode for CliShopClose {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopClose {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/cli_shop_list_req.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShopListReq {
+    pub(crate) id: u16,
+}
+
+impl PacketPayload for CliShopListReq {}
+
+impl Encode for CliShopListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        Ok(Self { id })
+    }
+}

packet-service/src/packets/cli_shop_open.rs

@@ -0,0 +1,158 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+    pub(crate) price: u32,
+}
+
+impl Encode for ShopItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.price.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let price = u32::decode(decoder)?;
+        Ok(Self { index, item, price })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopOpen {
+    pub(crate) sell_count: u8,
+    pub(crate) wishlist_count: u8,
+    pub(crate) items: Vec<ShopItem>,
+}
+
+impl PacketPayload for CliShopOpen {}
+
+impl Encode for CliShopOpen {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sell_count.encode(encoder)?;
+        self.wishlist_count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopOpen {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sell_count = u8::decode(decoder)?;
+        let wishlist_count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self {
+            sell_count,
+            wishlist_count,
+            items,
+        })
+    }
+}

packet-service/src/packets/cli_shop_sell_req.rs

@@ -0,0 +1,158 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopSellItem {
+    pub(crate) inventory_index: u8,
+    pub(crate) wishlist_index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopSellItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory_index.encode(encoder)?;
+        self.wishlist_index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopSellItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory_index = u8::decode(decoder)?;
+        let wishlist_index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self {
+            inventory_index,
+            wishlist_index,
+            item,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopSellReq {
+    pub(crate) id: u16,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopSellItem>,
+}
+
+impl PacketPayload for CliShopSellReq {}
+
+impl Encode for CliShopSellReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopSellReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { id, count, items })
+    }
+}

packet-service/src/packets/cli_shout_chat.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShoutChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliShoutChat {}
+
+impl Encode for CliShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}

packet-service/src/packets/cli_skill_cast_position.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastPosition {
+    pub(crate) slot: u8,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliSkillCastPosition {}
+
+impl Encode for CliSkillCastPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { slot, x, y })
+    }
+}

packet-service/src/packets/cli_skill_cast_self.rs

@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastSelf {
+    pub(crate) slot: u8,
+}
+
+impl PacketPayload for CliSkillCastSelf {}
+
+impl Encode for CliSkillCastSelf {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastSelf {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        Ok(Self { slot })
+    }
+}

packet-service/src/packets/cli_skill_cast_target.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastTarget {
+    pub(crate) target: u16,
+    pub(crate) slot: u8,
+}
+
+impl PacketPayload for CliSkillCastTarget {}
+
+impl Encode for CliSkillCastTarget {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastTarget {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        Ok(Self { target, slot })
+    }
+}

packet-service/src/packets/cli_skill_level_req.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillLevelReq {
+    pub(crate) slot: u8,
+    pub(crate) next_index: i16,
+}
+
+impl PacketPayload for CliSkillLevelReq {}
+
+impl Encode for CliSkillLevelReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.next_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillLevelReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let next_index = i16::decode(decoder)?;
+        Ok(Self { slot, next_index })
+    }
+}

packet-service/src/packets/cli_srv_select_req.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSrvSelectReq {
+    pub(crate) server_id: u32,
+    pub(crate) channel_id: u8,
+}
+
+impl PacketPayload for CliSrvSelectReq {}
+
+impl Encode for CliSrvSelectReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.server_id.encode(encoder)?;
+        self.channel_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSrvSelectReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let server_id = u32::decode(decoder)?;
+        let channel_id = u8::decode(decoder)?;
+        Ok(Self { server_id, channel_id })
+    }
+}

packet-service/src/packets/cli_stat_add_req.rs

@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Stat {
+    Str = 0,
+    Dex = 1,
+    Int = 2,
+    Con = 3,
+    Cha = 4,
+    Sen = 5,
+}
+
+impl Encode for Stat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Stat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Stat::Str),
+            1 => Ok(Stat::Dex),
+            2 => Ok(Stat::Int),
+            3 => Ok(Stat::Con),
+            4 => Ok(Stat::Cha),
+            5 => Ok(Stat::Sen),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Stat: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliStatAddReq {
+    pub(crate) stat: Stat,
+}
+
+impl PacketPayload for CliStatAddReq {}
+
+impl Encode for CliStatAddReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.stat.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStatAddReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let stat = Stat::decode(decoder)?;
+        Ok(Self { stat })
+    }
+}

packet-service/src/packets/cli_stop.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliStop {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliStop {}
+
+impl Encode for CliStop {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStop {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { x, y })
+    }
+}

packet-service/src/packets/cli_stop_moving.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliStopMoving {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliStopMoving {}
+
+impl Encode for CliStopMoving {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStopMoving {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { x, y, z })
+    }
+}

packet-service/src/packets/cli_store_trade_req.rs

@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum StoreTradeResult {
+    PriceDiff = 1,
+    InvalidNpc = 2,
+    TooFar = 3,
+    NoMoney = 4,
+    InvalidUnion = 5,
+    NoPoints = 6,
+}
+
+impl Encode for StoreTradeResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for StoreTradeResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(StoreTradeResult::PriceDiff),
+            2 => Ok(StoreTradeResult::InvalidNpc),
+            3 => Ok(StoreTradeResult::TooFar),
+            4 => Ok(StoreTradeResult::NoMoney),
+            5 => Ok(StoreTradeResult::InvalidUnion),
+            6 => Ok(StoreTradeResult::NoPoints),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for StoreTradeResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliStoreTradeReq {
+    pub(crate) result: StoreTradeResult,
+}
+
+impl PacketPayload for CliStoreTradeReq {}
+
+impl Encode for CliStoreTradeReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStoreTradeReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = StoreTradeResult::decode(decoder)?;
+        Ok(Self { result })
+    }
+}

packet-service/src/packets/cli_teleport_req.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliTeleportReq {
+    pub(crate) id: i16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliTeleportReq {}
+
+impl Encode for CliTeleportReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTeleportReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = i16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { id, x, y })
+    }
+}

packet-service/src/packets/cli_toggle_move.rs

@@ -0,0 +1,60 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ToggleMove {
+    Run = 0,
+    Sit = 1,
+    Drive = 2,
+}
+
+impl Encode for ToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(ToggleMove::Run),
+            1 => Ok(ToggleMove::Sit),
+            2 => Ok(ToggleMove::Drive),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ToggleMove: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliToggleMove {
+    pub(crate) type_: ToggleMove,
+}
+
+impl PacketPayload for CliToggleMove {}
+
+impl Encode for CliToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = ToggleMove::decode(decoder)?;
+        Ok(Self { type_ })
+    }
+}

packet-service/src/packets/cli_trade.rs

@@ -0,0 +1,84 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum TradeState {
+    Request = 0,
+    Accept = 1,
+    Reject = 2,
+    Cancel = 3,
+    Ready = 4,
+    Notready = 5,
+    Done = 6,
+    Busy = 7,
+    TooFar = 8,
+    InvalidTarget = 9,
+    NoSpace = 10,
+    TradeDisabled = 11,
+}
+
+impl Encode for TradeState {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for TradeState {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(TradeState::Request),
+            1 => Ok(TradeState::Accept),
+            2 => Ok(TradeState::Reject),
+            3 => Ok(TradeState::Cancel),
+            4 => Ok(TradeState::Ready),
+            5 => Ok(TradeState::Notready),
+            6 => Ok(TradeState::Done),
+            7 => Ok(TradeState::Busy),
+            8 => Ok(TradeState::TooFar),
+            9 => Ok(TradeState::InvalidTarget),
+            10 => Ok(TradeState::NoSpace),
+            11 => Ok(TradeState::TradeDisabled),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for TradeState: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliTrade {
+    pub(crate) state: TradeState,
+    pub(crate) target: u16,
+    pub(crate) index: u8,
+}
+
+impl PacketPayload for CliTrade {}
+
+impl Encode for CliTrade {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.state.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTrade {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let state = TradeState::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        Ok(Self { state, target, index })
+    }
+}

packet-service/src/packets/cli_trade_item.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliTradeItem {
+    pub(crate) slot: u8,
+    pub(crate) index: u16,
+    pub(crate) amount: u32,
+}
+
+impl PacketPayload for CliTradeItem {}
+
+impl Encode for CliTradeItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.index.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTradeItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        let amount = u32::decode(decoder)?;
+        Ok(Self { slot, index, amount })
+    }
+}

packet-service/src/packets/cli_use_item.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliUseItem {
+    pub(crate) index: u16,
+    pub(crate) item_id: u16,
+}
+
+impl PacketPayload for CliUseItem {}
+
+impl Encode for CliUseItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliUseItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let item_id = u16::decode(decoder)?;
+        Ok(Self { index, item_id })
+    }
+}

packet-service/src/packets/cli_whisper_chat.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliWhisperChat {
+    pub(crate) target: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliWhisperChat {}
+
+impl Encode for CliWhisperChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliWhisperChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { target, message })
+    }
+}

packet-service/src/packets/cli_wishlist_add.rs

@@ -0,0 +1,126 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliWishlistAdd {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for CliWishlistAdd {}
+
+impl Encode for CliWishlistAdd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliWishlistAdd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}

packet-service/src/packets/mod.rs

@@ -0,0 +1,199 @@
+pub mod cli_accept_req;
+pub mod cli_alive;
+pub mod cli_allied_chat;
+pub mod cli_allied_shout_chat;
+pub mod cli_appraisal_req;
+pub mod cli_attack;
+pub mod cli_bank_list_req;
+pub mod cli_bank_move_item;
+pub mod cli_bank_move_money;
+pub mod cli_change_char_req;
+pub mod cli_change_map_req;
+pub mod cli_channel_list_req;
+pub mod cli_char_list_req;
+pub mod cli_chatroom;
+pub mod cli_chatroom_message;
+pub mod cli_clan_chat;
+pub mod cli_clan_command;
+pub mod cli_clan_icon_req;
+pub mod cli_clan_icon_set;
+pub mod cli_clan_icon_timestamp;
+pub mod cli_craft_enhance_req;
+pub mod cli_craft_req;
+pub mod cli_craft_status;
+pub mod cli_create_char_req;
+pub mod cli_damage;
+pub mod cli_delete_char_req;
+pub mod cli_drop_item;
+pub mod cli_equip_item;
+pub mod cli_equip_item_ride;
+pub mod cli_equip_projectile;
+pub mod cli_hotbar_set_icon_req;
+pub mod cli_hp_req;
+pub mod cli_join_server_req;
+pub mod cli_join_server_token_req;
+pub mod cli_login_req;
+pub mod cli_login_token_req;
+pub mod cli_logout_req;
+pub mod cli_memo;
+pub mod cli_messenger;
+pub mod cli_messenger_chat;
+pub mod cli_mouse_cmd;
+pub mod cli_normal_chat;
+pub mod cli_party_chat;
+pub mod cli_party_reply;
+pub mod cli_party_req;
+pub mod cli_party_rule;
+pub mod cli_pickup_item_req;
+pub mod cli_quest_data_req;
+pub mod cli_repair_npc;
+pub mod cli_repair_use_item;
+pub mod cli_revive_req;
+pub mod cli_revive_set_pos;
+pub mod cli_ride_request;
+pub mod cli_screen_shot_time_req;
+pub mod cli_select_char_req;
+pub mod cli_set_animation;
+pub mod cli_set_position;
+pub mod cli_set_server_var_req;
+pub mod cli_set_weight_req;
+pub mod cli_shop_buy_req;
+pub mod cli_shop_buysell_reply;
+pub mod cli_shop_close;
+pub mod cli_shop_list_req;
+pub mod cli_shop_open;
+pub mod cli_shop_sell_req;
+pub mod cli_shout_chat;
+pub mod cli_skill_cast_position;
+pub mod cli_skill_cast_self;
+pub mod cli_skill_cast_target;
+pub mod cli_skill_level_req;
+pub mod cli_srv_select_req;
+pub mod cli_stat_add_req;
+pub mod cli_stop;
+pub mod cli_stop_moving;
+pub mod cli_store_trade_req;
+pub mod cli_teleport_req;
+pub mod cli_toggle_move;
+pub mod cli_trade;
+pub mod cli_trade_item;
+pub mod cli_use_item;
+pub mod cli_whisper_chat;
+pub mod cli_wishlist_add;
+pub mod srv_accept_reply;
+pub mod srv_allied_chat;
+pub mod srv_allied_shout_chat;
+pub mod srv_announce_chat;
+pub mod srv_appraisal_reply;
+pub mod srv_attack;
+pub mod srv_bank_list_reply;
+pub mod srv_bank_move_item;
+pub mod srv_bank_move_money;
+pub mod srv_billing_message;
+pub mod srv_chan_char_reply;
+pub mod srv_change_map_reply;
+pub mod srv_change_skin;
+pub mod srv_channel_list_reply;
+pub mod srv_char_list_reply;
+pub mod srv_char_state_change;
+pub mod srv_chatroom;
+pub mod srv_chatroom_message;
+pub mod srv_clan_chat;
+pub mod srv_clan_command;
+pub mod srv_clan_icon_reply;
+pub mod srv_clan_icon_timestamp;
+pub mod srv_clear_status;
+pub mod srv_craft_enhance_reply;
+pub mod srv_craft_reply;
+pub mod srv_craft_status;
+pub mod srv_create_char_reply;
+pub mod srv_damage;
+pub mod srv_delete_char_reply;
+pub mod srv_drop_item;
+pub mod srv_equip_item;
+pub mod srv_equip_item_ride;
+pub mod srv_equip_projectile;
+pub mod srv_event_add;
+pub mod srv_event_status;
+pub mod srv_fairy;
+pub mod srv_global_flags;
+pub mod srv_global_vars;
+pub mod srv_gm_command_code;
+pub mod srv_hotbar_set_icon_reply;
+pub mod srv_hp_reply;
+pub mod srv_inventory_data;
+pub mod srv_join_server_reply;
+pub mod srv_levelup;
+pub mod srv_login_reply;
+pub mod srv_logout_reply;
+pub mod srv_memo;
+pub mod srv_messenger;
+pub mod srv_messenger_chat;
+pub mod srv_mob_char;
+pub mod srv_mouse_cmd;
+pub mod srv_move;
+pub mod srv_normal_chat;
+pub mod srv_npc_char;
+pub mod srv_npc_event;
+pub mod srv_npc_show;
+pub mod srv_party_chat;
+pub mod srv_party_item;
+pub mod srv_party_levelexp;
+pub mod srv_party_member;
+pub mod srv_party_member_update;
+pub mod srv_party_reply;
+pub mod srv_party_req;
+pub mod srv_party_rule;
+pub mod srv_pickup_item_reply;
+pub mod srv_player_char;
+pub mod srv_quest_data;
+pub mod srv_quest_data_reply;
+pub mod srv_quest_reward_add_value;
+pub mod srv_quest_reward_set_value;
+pub mod srv_remove_object;
+pub mod srv_revive_reply;
+pub mod srv_ride_request;
+pub mod srv_ride_state_change;
+pub mod srv_screen_shot_time_reply;
+pub mod srv_select_char_reply;
+pub mod srv_server_data;
+pub mod srv_set_animation;
+pub mod srv_set_exp;
+pub mod srv_set_hp_and_mp;
+pub mod srv_set_item;
+pub mod srv_set_item_life;
+pub mod srv_set_money;
+pub mod srv_set_money_and_item;
+pub mod srv_set_position;
+pub mod srv_set_server_var_reply;
+pub mod srv_set_weight;
+pub mod srv_setexp;
+pub mod srv_shop_close;
+pub mod srv_shop_list_reply;
+pub mod srv_shop_open;
+pub mod srv_shout_chat;
+pub mod srv_skill_cancel;
+pub mod srv_skill_cast_position;
+pub mod srv_skill_cast_self;
+pub mod srv_skill_cast_target;
+pub mod srv_skill_damage;
+pub mod srv_skill_effect;
+pub mod srv_skill_finish;
+pub mod srv_skill_learn;
+pub mod srv_skill_level_reply;
+pub mod srv_skill_start;
+pub mod srv_speed_changed;
+pub mod srv_srv_select_reply;
+pub mod srv_stat_add_reply;
+pub mod srv_stop;
+pub mod srv_stop_moving;
+pub mod srv_store_trade_reply;
+pub mod srv_switch_server;
+pub mod srv_teleport_reply;
+pub mod srv_toggle_move;
+pub mod srv_trade;
+pub mod srv_trade_item;
+pub mod srv_update_name;
+pub mod srv_update_npc;
+pub mod srv_use_item;
+pub mod srv_whisper_chat;

packet-service/src/packets/srv_accept_reply.rs

@@ -0,0 +1,65 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Connect = 1,
+    Accepted = 2,
+    Disconnect = 3,
+    Derverdead = 4,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(Result::Connect),
+            2 => Ok(Result::Accepted),
+            3 => Ok(Result::Disconnect),
+            4 => Ok(Result::Derverdead),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvAcceptReply {
+    pub(crate) result: Result,
+    pub(crate) rand_value: u32,
+}
+
+impl PacketPayload for SrvAcceptReply {}
+
+impl Encode for SrvAcceptReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.rand_value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAcceptReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let rand_value = u32::decode(decoder)?;
+        Ok(Self { result, rand_value })
+    }
+}

packet-service/src/packets/srv_allied_chat.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAlliedChat {
+    pub(crate) team: u32,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAlliedChat {}
+
+impl Encode for SrvAlliedChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.team.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAlliedChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let team = u32::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { team, message })
+    }
+}

packet-service/src/packets/srv_allied_shout_chat.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAlliedShoutChat {
+    pub(crate) team: u32,
+    pub(crate) sender: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAlliedShoutChat {}
+
+impl Encode for SrvAlliedShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.team.encode(encoder)?;
+        self.sender.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAlliedShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let team = u32::decode(decoder)?;
+        let sender = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { team, sender, message })
+    }
+}

packet-service/src/packets/srv_announce_chat.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAnnounceChat {
+    pub(crate) message: NullTerminatedString,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAnnounceChat {}
+
+impl Encode for SrvAnnounceChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAnnounceChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message, name })
+    }
+}

packet-service/src/packets/srv_appraisal_reply.rs

@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct AppraisalReply {
+    pub(crate) index: u16,
+    pub(crate) result: u8,
+}
+
+impl Encode for AppraisalReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for AppraisalReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let result = u8::decode(decoder)?;
+        Ok(Self { index, result })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvAppraisalReply {
+    pub(crate) result: AppraisalReply,
+}
+
+impl PacketPayload for SrvAppraisalReply {}
+
+impl Encode for SrvAppraisalReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAppraisalReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = AppraisalReply::decode(decoder)?;
+        Ok(Self { result })
+    }
+}

packet-service/src/packets/srv_attack.rs

@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAttack {
+    pub(crate) attacker_id: u16,
+    pub(crate) defender_id: u16,
+    pub(crate) distance: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for SrvAttack {}
+
+impl Encode for SrvAttack {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.attacker_id.encode(encoder)?;
+        self.defender_id.encode(encoder)?;
+        self.distance.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAttack {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let attacker_id = u16::decode(decoder)?;
+        let defender_id = u16::decode(decoder)?;
+        let distance = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self {
+            attacker_id,
+            defender_id,
+            distance,
+            x,
+            y,
+            z,
+        })
+    }
+}

packet-service/src/packets/srv_bank_list_reply.rs

@@ -0,0 +1,183 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankListReply {
+    InitData = 0,
+    ShowData = 1,
+    NeedPassword = 2,
+    ChangedPassword = 3,
+    ClearedPassword = 4,
+    Platinum = 5,
+}
+
+impl Encode for BankListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankListReply::InitData),
+            1 => Ok(BankListReply::ShowData),
+            2 => Ok(BankListReply::NeedPassword),
+            3 => Ok(BankListReply::ChangedPassword),
+            4 => Ok(BankListReply::ClearedPassword),
+            5 => Ok(BankListReply::Platinum),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankListReply: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct BankListItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for BankListItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for BankListItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvBankListReply {
+    pub(crate) reply: BankListReply,
+    pub(crate) items: Vec<BankListItem>,
+}
+
+impl PacketPayload for SrvBankListReply {}
+
+impl Encode for SrvBankListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.reply.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let reply = BankListReply::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { reply, items })
+    }
+}

packet-service/src/packets/srv_bank_move_item.rs

@@ -0,0 +1,141 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvBankMoveItem {
+    pub(crate) inventory_index: i16,
+    pub(crate) bank_index: i16,
+    pub(crate) inventory_item: Item,
+    pub(crate) bank_item: Item,
+    pub(crate) money: i64,
+}
+
+impl PacketPayload for SrvBankMoveItem {}
+
+impl Encode for SrvBankMoveItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory_index.encode(encoder)?;
+        self.bank_index.encode(encoder)?;
+        self.inventory_item.encode(encoder)?;
+        self.bank_item.encode(encoder)?;
+        self.money.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankMoveItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory_index = i16::decode(decoder)?;
+        let bank_index = i16::decode(decoder)?;
+        let inventory_item = Item::decode(decoder)?;
+        let bank_item = Item::decode(decoder)?;
+        let money = i64::decode(decoder)?;
+        Ok(Self {
+            inventory_index,
+            bank_index,
+            inventory_item,
+            bank_item,
+            money,
+        })
+    }
+}

packet-service/src/packets/srv_bank_move_money.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvBankMoveMoney {
+    pub(crate) inventory: i64,
+    pub(crate) bank: i64,
+}
+
+impl PacketPayload for SrvBankMoveMoney {}
+
+impl Encode for SrvBankMoveMoney {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory.encode(encoder)?;
+        self.bank.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankMoveMoney {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory = i64::decode(decoder)?;
+        let bank = i64::decode(decoder)?;
+        Ok(Self { inventory, bank })
+    }
+}

packet-service/src/packets/srv_billing_message.rs

@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvBillingMessage {
+    pub(crate) function_type: u16,
+    pub(crate) pay_flag: u32,
+}
+
+impl PacketPayload for SrvBillingMessage {}
+
+impl Encode for SrvBillingMessage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.function_type.encode(encoder)?;
+        self.pay_flag.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBillingMessage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let function_type = u16::decode(decoder)?;
+        let pay_flag = u32::decode(decoder)?;
+        Ok(Self {
+            function_type,
+            pay_flag,
+        })
+    }
+}

packet-service/src/packets/srv_chan_char_reply.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChanCharReply {}
+
+impl PacketPayload for SrvChanCharReply {}
+
+impl Encode for SrvChanCharReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChanCharReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}

packet-service/src/packets/srv_change_map_reply.rs

@@ -0,0 +1,86 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChangeMapReply {
+    pub(crate) object_index: u16,
+    pub(crate) hp: u16,
+    pub(crate) mp: u16,
+    pub(crate) xp: u16,
+    pub(crate) penalize_xp: u16,
+    pub(crate) craft_rate: u16,
+    pub(crate) update_time: u16,
+    pub(crate) world_rate: u16,
+    pub(crate) town_rate: u8,
+    pub(crate) item_rate: [u8; (MAX_SELL_TYPE as usize)],
+    pub(crate) flags: u32,
+    pub(crate) world_time: u16,
+    pub(crate) team_number: u16,
+}
+
+impl PacketPayload for SrvChangeMapReply {}
+
+impl Encode for SrvChangeMapReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.object_index.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.mp.encode(encoder)?;
+        self.xp.encode(encoder)?;
+        self.penalize_xp.encode(encoder)?;
+        self.craft_rate.encode(encoder)?;
+        self.update_time.encode(encoder)?;
+        self.world_rate.encode(encoder)?;
+        self.town_rate.encode(encoder)?;
+        for value in &self.item_rate {
+            value.encode(encoder)?;
+        }
+        self.flags.encode(encoder)?;
+        self.world_time.encode(encoder)?;
+        self.team_number.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChangeMapReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let object_index = u16::decode(decoder)?;
+        let hp = u16::decode(decoder)?;
+        let mp = u16::decode(decoder)?;
+        let xp = u16::decode(decoder)?;
+        let penalize_xp = u16::decode(decoder)?;
+        let craft_rate = u16::decode(decoder)?;
+        let update_time = u16::decode(decoder)?;
+        let world_rate = u16::decode(decoder)?;
+        let town_rate = u8::decode(decoder)?;
+        let mut item_rate = [0u8; (MAX_SELL_TYPE as usize)];
+        for value in &mut item_rate {
+            *value = u8::decode(decoder)?;
+        }
+        let flags = u32::decode(decoder)?;
+        let world_time = u16::decode(decoder)?;
+        let team_number = u16::decode(decoder)?;
+        Ok(Self {
+            object_index,
+            hp,
+            mp,
+            xp,
+            penalize_xp,
+            craft_rate,
+            update_time,
+            world_rate,
+            town_rate,
+            item_rate,
+            flags,
+            world_time,
+            team_number,
+        })
+    }
+}

packet-service/src/packets/srv_change_skin.rs

@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPositionRide {
+    Body = 0,
+    Engine = 1,
+    Leg = 2,
+    Ability = 3,
+    Arm = 4,
+}
+
+impl Encode for EquippedPositionRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPositionRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPositionRide::Body),
+            1 => Ok(EquippedPositionRide::Engine),
+            2 => Ok(EquippedPositionRide::Leg),
+            3 => Ok(EquippedPositionRide::Ability),
+            4 => Ok(EquippedPositionRide::Arm),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPositionRide: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvChangeSkin {
+    pub(crate) char_id: u16,
+    pub(crate) slot: EquippedPositionRide,
+    pub(crate) item_id: u32,
+}
+
+impl PacketPayload for SrvChangeSkin {}
+
+impl Encode for SrvChangeSkin {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChangeSkin {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let slot = EquippedPositionRide::decode(decoder)?;
+        let item_id = u32::decode(decoder)?;
+        Ok(Self { char_id, slot, item_id })
+    }
+}

packet-service/src/packets/srv_channel_list_reply.rs

@@ -0,0 +1,71 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct ChannelInfo {
+    pub(crate) id: u8,
+    pub(crate) low_age: u8,
+    pub(crate) high_age: u8,
+    pub(crate) capacity: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl Encode for ChannelInfo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.low_age.encode(encoder)?;
+        self.high_age.encode(encoder)?;
+        self.capacity.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ChannelInfo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u8::decode(decoder)?;
+        let low_age = u8::decode(decoder)?;
+        let high_age = u8::decode(decoder)?;
+        let capacity = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            id,
+            low_age,
+            high_age,
+            capacity,
+            name,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvChannelListReply {
+    pub(crate) id: u32,
+    pub(crate) channels: Vec<ChannelInfo>,
+}
+
+impl PacketPayload for SrvChannelListReply {}
+
+impl Encode for SrvChannelListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.channels.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChannelListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u32::decode(decoder)?;
+        let channels = Vec::decode(decoder)?;
+        Ok(Self { id, channels })
+    }
+}

packet-service/src/packets/srv_char_list_reply.rs

@@ -0,0 +1,161 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPosition {
+    Helmet = 0,
+    Armor = 1,
+    Gauntlet = 2,
+    Boots = 3,
+    Googles = 4,
+    Backpack = 5,
+    WeaponR = 6,
+    WeaponL = 7,
+    MaxItems = 8,
+}
+
+impl Encode for EquippedPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPosition::Helmet),
+            1 => Ok(EquippedPosition::Armor),
+            2 => Ok(EquippedPosition::Gauntlet),
+            3 => Ok(EquippedPosition::Boots),
+            4 => Ok(EquippedPosition::Googles),
+            5 => Ok(EquippedPosition::Backpack),
+            6 => Ok(EquippedPosition::WeaponR),
+            7 => Ok(EquippedPosition::WeaponL),
+            8 => Ok(EquippedPosition::MaxItems),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPosition: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct CharInfo {
+    pub(crate) name: NullTerminatedString,
+    pub(crate) race: u8,
+    pub(crate) level: u16,
+    pub(crate) job: u16,
+    pub(crate) remain_secs_until_delete: u32,
+    pub(crate) platinium: u8,
+    pub(crate) face: u32,
+    pub(crate) hair: u32,
+    pub(crate) items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)],
+}
+
+impl Encode for CharInfo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.name.encode(encoder)?;
+        self.race.encode(encoder)?;
+        self.level.encode(encoder)?;
+        self.job.encode(encoder)?;
+        self.remain_secs_until_delete.encode(encoder)?;
+        self.platinium.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CharInfo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let name = NullTerminatedString::decode(decoder)?;
+        let race = u8::decode(decoder)?;
+        let level = u16::decode(decoder)?;
+        let job = u16::decode(decoder)?;
+        let remain_secs_until_delete = u32::decode(decoder)?;
+        let platinium = u8::decode(decoder)?;
+        let face = u32::decode(decoder)?;
+        let hair = u32::decode(decoder)?;
+        let mut items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)] = core::array::from_fn(|i| EquippedItem::default());
+        for index in 0..MAX_VISIBLE_ITEMS as usize {
+            items[index] = EquippedItem::decode(decoder)?;
+        }
+        Ok(Self {
+            name,
+            race,
+            level,
+            job,
+            remain_secs_until_delete,
+            platinium,
+            face,
+            hair,
+            items,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCharListReply {
+    pub(crate) characters: Vec<CharInfo>,
+}
+
+impl PacketPayload for SrvCharListReply {}
+
+impl Encode for SrvCharListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.characters.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCharListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let characters = Vec::decode(decoder)?;
+        Ok(Self { characters })
+    }
+}

packet-service/src/packets/srv_char_state_change.rs

@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvCharStateChange {
+    pub(crate) target: u16,
+    pub(crate) flag: u32,
+}
+
+impl PacketPayload for SrvCharStateChange {}
+
+impl Encode for SrvCharStateChange {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.flag.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCharStateChange {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let flag = u32::decode(decoder)?;
+        Ok(Self { target, flag })
+    }
+}

packet-service/src/packets/srv_chatroom.rs

@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChatroom {}
+
+impl PacketPayload for SrvChatroom {}
+
+impl Encode for SrvChatroom {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChatroom {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}