Char restoration works now

entities/src/dao/character.rs

@@ -33,6 +33,14 @@ impl character::Model {
         active_model.delete_at = ActiveValue::Set(Some((Utc::now() + Duration::days(7)).into()));
         active_model.update(db_pool).await
     }
+    pub async fn restore_char(
+        db_pool: &DBPool,
+        c: character::Model,
+    ) -> Result<character::Model, DbErr> {
+        let mut active_model: character::ActiveModel = c.into();
+        active_model.delete_at = ActiveValue::Set(None);
+        active_model.update(db_pool).await
+    }
     pub async fn find_by_username(
         db_pool: &DBPool,
         username: &str,

game/src/client_thread/handler.rs

@@ -115,6 +115,20 @@ impl ClientHandler {
         }
         Ok(())
     }
+    #[allow(clippy::cast_sign_loss)]
+    pub async fn restore_char_by_slot_id(&mut self, slot_id: i32) -> anyhow::Result<()> {
+        if let Some(chars) = self.account_chars.as_mut() {
+            if slot_id >= i32::try_from(chars.len())? || slot_id < 0 {
+                bail!("Missing character at slot: {slot_id}")
+            }
+            let mut char_info: CharacterInfo = chars.remove(slot_id as usize);
+            let model = char_info.char_model.clone();
+            let updated_char = character::Model::restore_char(&self.db_pool, model).await?;
+            char_info.char_model = updated_char;
+            chars.insert(slot_id as usize, char_info);
+        }
+        Ok(())
+    }
 
     pub fn set_encryption(&mut self, bf_key: Option<Encryption>) {
         self.blowfish = bf_key;

game/src/cp_factory.rs

@@ -11,6 +11,7 @@ use crate::packets::HandleablePacket;
 use anyhow::bail;
 use l2_core::shared_packets::common::ReadablePacket;
 use tracing::error;
+use crate::packets::from_client::char_restore::RestoreChar;
 use crate::packets::from_client::delete_char::DeleteChar;
 use crate::packets::from_client::logout::Logout;
 
@@ -28,6 +29,7 @@ pub fn build_client_packet(
         CreateCharRequest::PACKET_ID => Ok(Box::new(CreateCharRequest::read(packet_body)?)),
         Logout::PACKET_ID => Ok(Box::new(Logout::read(packet_body)?)),
         DeleteChar::PACKET_ID => Ok(Box::new(DeleteChar::read(packet_body)?)),
+        RestoreChar::PACKET_ID => Ok(Box::new(RestoreChar::read(packet_body)?)),
         0xD0 => build_ex_client_packet(packet_body),
         _ => {
             error!("Unknown GS packet ID:0x{:02X}", data[0]);

game/src/packets/from_client/char_restore.rs

@@ -0,0 +1,51 @@
+use crate::client_thread::ClientHandler;
+use crate::packets::to_client::CharSelectionInfo;
+use crate::packets::HandleablePacket;
+use async_trait::async_trait;
+use tracing::info;
+use l2_core::shared_packets::common::ReadablePacket;
+use l2_core::shared_packets::read::ReadablePacketBuffer;
+use l2_core::traits::handlers::{PacketHandler, PacketSender};
+
+#[derive(Debug, Clone)]
+pub struct RestoreChar {
+    char_slot: i32,
+}
+
+impl ReadablePacket for RestoreChar {
+    const PACKET_ID: u8 = 0x7B;
+    const EX_PACKET_ID: Option<u16> = None;
+    fn read(data: &[u8]) -> anyhow::Result<Self> {
+        let mut buffer = ReadablePacketBuffer::new(data.to_vec());
+        Ok(Self {
+            char_slot: buffer.read_i32(),
+        })
+    }
+}
+
+#[async_trait]
+impl HandleablePacket for RestoreChar {
+    type HandlerType = ClientHandler;
+    async fn handle(&self, handler: &mut Self::HandlerType) -> anyhow::Result<()> {
+        //todo flood protection
+        info!("Restore slot: {}", self.char_slot);
+        handler.restore_char_by_slot_id(self.char_slot).await?;
+        let sk = handler.get_session_key().ok_or(anyhow::anyhow!(
+            "Error after char restoration, Session is missing"
+        ))?;
+        let chars = handler.get_account_chars().ok_or(anyhow::anyhow!(
+            "Programming error, seems like all chars dropped from the list during restoration"
+        ))?;
+        let controller = handler.get_controller();
+        let user_name = &handler
+            .user
+            .as_ref()
+            .ok_or(anyhow::anyhow!(
+                "Programming error, or possible cheating: missing user in handler for char restoration"
+            ))?
+            .username;
+        let p = CharSelectionInfo::new(user_name, sk.get_play_session_id(), controller, chars)?;
+        handler.send_packet(Box::new(p)).await?;
+        Ok(())
+    }
+}

game/src/packets/from_client/delete_char.rs

@@ -2,7 +2,6 @@ use crate::client_thread::ClientHandler;
 use crate::packets::to_client::CharSelectionInfo;
 use crate::packets::HandleablePacket;
 use async_trait::async_trait;
-use tracing::info;
 use l2_core::shared_packets::common::ReadablePacket;
 use l2_core::shared_packets::read::ReadablePacketBuffer;
 use l2_core::traits::handlers::{PacketHandler, PacketSender};
@@ -27,6 +26,7 @@ impl ReadablePacket for DeleteChar {
 impl HandleablePacket for DeleteChar {
     type HandlerType = ClientHandler;
     async fn handle(&self, handler: &mut Self::HandlerType) -> anyhow::Result<()> {
+        //todo handle proper deletion checks, e.g. check in clan, war, and so on
         handler.delete_char_by_slot_id(self.char_slot).await?;
         let sk = handler.get_session_key().ok_or(anyhow::anyhow!(
             "Error after char deletion, Session is missing"

game/src/packets/from_client/mod.rs

@@ -5,4 +5,5 @@ pub mod new_char_request;
 pub mod extended;
 pub mod char_create;
 pub mod logout;
-pub mod delete_char;
+pub mod delete_char;
+pub mod char_restore;

game/src/packets/to_client/char_delete_fail.rs

@@ -0,0 +1,24 @@
+use l2_core::enums::CharDeletionFailReasons;
+use l2_core::shared_packets::write::SendablePacketBuffer;
+use macro_common::SendablePacketImpl;
+
+#[allow(unused)]
+#[derive(Debug, Clone, SendablePacketImpl)]
+pub struct CharDeleteFail {
+    buffer: SendablePacketBuffer,
+}
+
+#[allow(unused)]
+impl CharDeleteFail {
+    const PACKET_ID: u8 = 0x1E;
+    const EX_PACKET_ID: Option<u16> = None;
+
+    pub fn new(reason: CharDeletionFailReasons) -> anyhow::Result<Self> {
+        let mut inst = Self {
+            buffer: SendablePacketBuffer::new(),
+        };
+        inst.buffer.write(Self::PACKET_ID)?;
+        inst.buffer.write_i32(reason as i32)?;
+        Ok(inst)
+    }
+}

game/src/packets/to_client/char_selection.rs

@@ -52,7 +52,6 @@ impl CharSelectionInfo {
             buffer.write_i32(0)?; // clan id
             buffer.write_i32(0)?; // Builder level
             buffer.write_i32(i32::from(char.sex))?;
-            info!("Race id: {}", char.race_id);
             buffer.write_i32(i32::from(char.race_id))?; 
             buffer.write_i32(i32::from(char.base_class_id))?;
             buffer.write_i32(1)?; // GameServerName

game/src/packets/to_client/mod.rs

@@ -5,6 +5,7 @@ mod new_char_response;
 pub mod extended;
 mod char_create_fail;
 mod char_create_ok;
+mod char_delete_fail;
 
 pub use protocol_response::*;
 pub use login_response::*;

l2-core/src/enums.rs

@@ -0,0 +1,13 @@
+#[repr(i32)]
+#[derive(Clone, Debug)]
+pub enum CharDeletionFailReasons {
+    None,
+    Unknown,
+    PledgeMember,
+    PledgeMaster,
+    ProhibitCharDeletion,
+    Commission,
+    Mentor,
+    Mentee,
+    Mail,
+}

l2-core/src/lib.rs

@@ -19,6 +19,7 @@ pub mod shared_packets;
 pub mod str;
 pub mod tests;
 pub mod traits;
+pub mod enums;
 
 #[allow(clippy::missing_errors_doc, clippy::missing_panics_doc)]
 pub async fn hash_password(password: &str) -> anyhow::Result<String> {