- update: function calls to character service in the packet service now actually use the call the correct requests

- update: character select list builds the equipped item list dynamically

packet-service/src/character_client.rs

@@ -1,5 +1,5 @@
 use crate::char::character_service_client::CharacterServiceClient;
-use crate::char::{GetCharacterListRequest, GetCharacterListResponse, Character, EquippedItem};
+use crate::char::{GetCharacterRequest, GetCharacterListRequest, GetCharacterListResponse, Character, EquippedItem, DeleteCharacterRequest, Empty};
 use tonic::transport::Channel;
 
 #[derive(Clone, Debug)]
@@ -31,21 +31,22 @@ impl CharacterClient {
         Ok(response.into_inner())
     }
 
-    pub async fn delete_character(&mut self, user_id: &str) -> Result<GetCharacterListResponse, Box<dyn std::error::Error + Send + Sync>> {
-        let request = GetCharacterListRequest {
+    pub async fn delete_character(&mut self, user_id: &str, char_id: &str) -> Result<Empty, Box<dyn std::error::Error + Send + Sync>> {
+        let request = DeleteCharacterRequest {
             user_id: user_id.to_string(),
+            char_id: char_id.to_string(),
         };
 
-        let response = self.client.get_character_list(request).await?;
+        let response = self.client.delete_character(request).await?;
         Ok(response.into_inner())
     }
 
-    pub async fn get_character(&mut self, char_id: u8) -> Result<GetCharacterListResponse, Box<dyn std::error::Error + Send + Sync>> {
-        let request = GetCharacterListRequest {
+    pub async fn get_character(&mut self, user_id: &str, char_id: u8) -> Result<Empty, Box<dyn std::error::Error + Send + Sync>> {
+        let request = GetCharacterRequest {
             user_id: char_id.to_string(),
         };
 
-        let response = self.client.get_character_list(request).await?;
+        let response = self.client.get_character(request).await?;
         Ok(response.into_inner())
     }
 }

packet-service/src/handlers/character.rs

@@ -40,9 +40,20 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
     debug!("{:?}", character_list.characters);
     let mut characters = vec![];
     for character in character_list.characters {
-        // let item_list = character.items.iter().map(|item| {
-        //     
-        // });
+        let mut item_list = vec![EquippedItem {id: 0, gem_opt: 0, socket: 0, grade: 0}; MAX_VISIBLE_ITEMS as usize];
+
+        {
+            let mut index = 0;
+            let _ = character.items.iter().map(|item| {
+                item_list[index] = EquippedItem {
+                    id: item.id as u16,
+                    gem_opt: item.gem_option as u16,
+                    socket: item.socket as i8,
+                    grade: item.grade as u8,
+                };
+                index = index + 1;
+            });
+        }
         
         let character_info = CharInfo {
             name: NullTerminatedString(character.name),
@@ -53,7 +64,7 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
             platinium: 0,
             face: character.face as u32,
             hair: character.hair as u32,
-            items: vec![],
+            items: item_list,
         };
         characters.push(character_info);
     }
@@ -70,14 +81,16 @@ pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packe
     let request = CliCreateCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
+    let mut user_id = 0;
     let session_id;
     if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        user_id = state.user_id.expect("Missing user id in connection state");
         session_id = state.session_id.expect("Missing session id in connection state");
     }
     
     // send the data to the character service to create the character
     let mut character_client = character_client.lock().await;
-    // character_client.create_character(&session_id).await?;
+    character_client.create_character(&user_id.to_string()).await?;
 
     let data = SrvCreateCharReply { result: srv_create_char_reply::Result::Ok, platininum: 0 };
     let response_packet = Packet::new(PacketType::PakccCreateCharReply, &data)?;
@@ -90,13 +103,16 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe
     let request = CliDeleteCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
+    let mut user_id = 0;
     let session_id;
     if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        user_id = state.user_id.expect("Missing user id in connection state");
         session_id = state.session_id.expect("Missing session id in connection state");
     }
 
     let mut character_client = character_client.lock().await;
-    // character_client.set_delete_character(request.is_delete, request.char_id, request.name);
+    // character_client.delete_character(request.is_delete, request.char_id, request.name);
+    character_client.delete_character(&user_id.to_string(), &request.char_id.to_string());
 
     let character_name = request.name;
     let data = SrvDeleteCharReply { remaining_time: 0, name: character_name };
@@ -110,12 +126,14 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe
     let request = CliSelectCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
+    let mut user_id = 0;
     if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
+        user_id = state.user_id.expect("Missing user id in connection state");
         state.character_id = Some(request.char_id as i8);
     }
 
     let mut character_client = character_client.lock().await;
-    // character_client.get_character(request.char_id);
+    // character_client.get_character(&user_id.to_string(), request.char_id);
     let data = SrvSelectCharReply {
         race: 0,
         map: 0,