- update: packet router to have the various services needed for the packets to be local to it.

- add: character service grpc client calls

packet-service/src/handlers/character.rs

@@ -12,16 +12,18 @@ use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 use tonic::{Code, Status};
 use tracing::{debug, error, info, warn};
+use crate::auth_client::AuthClient;
+use crate::character_client::CharacterClient;
 use crate::connection_service::ConnectionService;
 use crate::packets::cli_create_char_req::CliCreateCharReq;
 use crate::packets::cli_delete_char_req::CliDeleteCharReq;
 use crate::packets::cli_select_char_req::CliSelectCharReq;
-use crate::packets::srv_char_list_reply::SrvCharListReply;
+use crate::packets::srv_char_list_reply::{CharInfo, EquippedItem, SrvCharListReply};
 use crate::packets::srv_create_char_reply::SrvCreateCharReply;
 use crate::packets::srv_delete_char_reply::SrvDeleteCharReply;
 use crate::packets::srv_select_char_reply::SrvSelectCharReply;
 
-pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, character_client: Arc<Mutex<CharacterClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliCharListReq::decode(packet.payload.as_slice());
     debug!("{:?}", request);
 
@@ -31,17 +33,40 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
         user_id = state.user_id.expect("Missing user id in connection state");
         session_id = state.session_id.expect("Missing session id in connection state");
     }
-    
+
     // query the character service for the character list for this user
-    
-    let data = SrvCharListReply { characters: vec![] };
+    let mut character_client = character_client.lock().await;
+    let character_list = character_client.get_character_list(&user_id.to_string()).await?;
+    debug!("{:?}", character_list.characters);
+    let mut characters = vec![];
+    for character in character_list.characters {
+        // let item_list = character.items.iter().map(|item| {
+        //     
+        // });
+        
+        let character_info = CharInfo {
+            name: NullTerminatedString(character.name),
+            race: character.race as u8,
+            level: character.level as u16,
+            job: character.job as u16,
+            remain_secs_until_delete: character.delete_time as u32,
+            platinium: 0,
+            face: character.face as u32,
+            hair: character.hair as u32,
+            items: vec![],
+        };
+        characters.push(character_info);
+    }
+
+    debug!("{:?}", characters);
+    let data = SrvCharListReply { characters };
     let response_packet = Packet::new(PacketType::PakccCharListReply, &data)?;
     send_packet(stream, &response_packet).await?;
     
     Ok(())
 }
 
-pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packet, character_client: Arc<Mutex<CharacterClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliCreateCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
@@ -51,6 +76,8 @@ pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packe
     }
     
     // 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?;
 
     let data = SrvCreateCharReply { result: srv_create_char_reply::Result::Ok, platininum: 0 };
     let response_packet = Packet::new(PacketType::PakccCreateCharReply, &data)?;
@@ -59,7 +86,7 @@ pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packe
     Ok(())
 }
 
-pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packet, character_client: Arc<Mutex<CharacterClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliDeleteCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
@@ -67,7 +94,8 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe
     if let Some(mut state) = connection_service.get_connection(&connection_id) {
         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);
 
     let character_name = request.name;
@@ -78,7 +106,7 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe
     Ok(())
 }
 
-pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packet, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packet, character_client: Arc<Mutex<CharacterClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliSelectCharReq::decode(packet.payload.as_slice())?;
     debug!("{:?}", request);
 
@@ -86,6 +114,8 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe
         state.character_id = Some(request.char_id as i8);
     }
 
+    let mut character_client = character_client.lock().await;
+    // character_client.get_character(request.char_id);
     let data = SrvSelectCharReply {
         race: 0,
         map: 0,