- 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

character-service/build.rs

@@ -11,6 +11,6 @@ fn main() {
     tonic_build::configure()
         .build_server(false) // Generate gRPC client code
         .compile_well_known_types(true)
-        .compile_protos(&["../proto/user_db_api.proto", "../proto/auth.proto"], &["../proto"])
+        .compile_protos(&["../proto/user_db_api.proto", "../proto/character_db_api.proto", "../proto/auth.proto"], &["../proto"])
         .unwrap_or_else(|e| panic!("Failed to compile protos {:?}", e));
 }

character-service/src/character_service.rs

@@ -2,7 +2,7 @@ use tracing::debug;
 use tonic::{Request, Response, Status};
 use tracing::field::debug;
 use crate::character_service::character::character_service_server::CharacterService;
-use crate::character_service::character::{Character, GetCharacterListRequest, GetCharacterListResponse};
+use crate::character_service::character::{Character, CreateCharacterRequest, DeleteCharacterRequest, Empty, GetCharacterListRequest, GetCharacterListResponse, GetCharacterRequest};
 
 pub mod character {
     tonic::include_proto!("character");
@@ -50,4 +50,16 @@ impl CharacterService for MyCharacterService {
         let response = GetCharacterListResponse { characters };
         Ok(Response::new(response))
     }
+
+    async fn create_character(&self, request: Request<CreateCharacterRequest>) -> Result<Response<Empty>, Status> {
+        todo!()
+    }
+
+    async fn delete_character(&self, request: Request<DeleteCharacterRequest>) -> Result<Response<Empty>, Status> {
+        todo!()
+    }
+
+    async fn get_character(&self, request: Request<GetCharacterRequest>) -> Result<Response<Empty>, Status> {
+        todo!()
+    }
 }

database-service/src/grpc/character_service.rs

@@ -1,4 +1,4 @@
-use crate::grpc::{CharacterRequest, CharacterResponse, CreateCharacterRequest, DeleteCharacterRequest, Empty};
+use crate::grpc::{Character, CharacterRequest, CharacterListRequest, CharacterListResponse, CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest, Empty};
 use crate::grpc::character_service_server::CharacterService;
 use crate::grpc::database_service::MyDatabaseService;
 use tonic::{Request, Response, Status};
@@ -8,7 +8,7 @@ impl CharacterService for MyDatabaseService {
     async fn get_character(
         &self,
         request: Request<CharacterRequest>,
-    ) -> Result<Response<CharacterResponse>, Status> {
+    ) -> Result<Response<Character>, Status> {
         let req = request.into_inner();
         let repo = &self.db.character_repo;
 
@@ -17,7 +17,7 @@ impl CharacterService for MyDatabaseService {
             .await
             .map_err(|_| Status::not_found("Character not found"))?;
 
-        let response = CharacterResponse {
+        let response = Character {
             id: character.id,
             user_id: character.user_id,
             name: character.name,
@@ -35,12 +35,53 @@ impl CharacterService for MyDatabaseService {
         Ok(Response::new(response))
     }
 
+    async fn get_character_list(
+        &self,
+        request: Request<CharacterListRequest>,
+    ) -> Result<Response<CharacterListResponse>, Status> {
+        let req = request.into_inner();
+        let repo = &self.db.character_repo;
+
+        let characters = repo
+            .get_characters_by_user(req.user_id)
+            .await
+            .map_err(|_| Status::not_found("Character not found"))?;
+        
+        let mut character_list: Vec<Character> = Vec::new();
+        
+        for character in characters {
+            let character = Character {
+                id: character.id,
+                user_id: character.user_id,
+                name: character.name,
+                level: character.level as i32,
+                experience: character.experience,
+                inventory: character.inventory.to_string(),
+                stats: character.stats.to_string(),
+                looks: character.looks.to_string(),
+                position: character.position.to_string(),
+                created_at: character.created_at.to_string(),
+                updated_at: character.updated_at.to_string(),
+                is_active: character.is_active,
+            };
+            character_list.push(character);
+        }
+
+        let response = CharacterListResponse {
+            characters: character_list,
+        };
+
+        Ok(Response::new(response))
+    }
+
     async fn create_character(
         &self,
         request: Request<CreateCharacterRequest>,
-    ) -> Result<Response<CharacterResponse>, Status> {
+    ) -> Result<Response<CreateCharacterResponse>, Status> {
         let req = request.into_inner();
         let repo = &self.db.character_repo;
+        
+        //todo: we need to check if the character name exists already
 
         let character_id = repo
             .create_character(
@@ -59,19 +100,8 @@ impl CharacterService for MyDatabaseService {
             .await
             .map_err(|_| Status::not_found("Character not found"))?;
 
-        let response = CharacterResponse {
-            id: character.id,
-            user_id: character.user_id,
-            name: character.name,
-            level: character.level as i32,
-            experience: character.experience,
-            inventory: character.inventory.to_string(),
-            stats: character.stats.to_string(),
-            looks: character.looks.to_string(),
-            position: character.position.to_string(),
-            created_at: character.created_at.to_string(),
-            updated_at: character.updated_at.to_string(),
-            is_active: character.is_active,
+        let response = CreateCharacterResponse {
+            character_id: character.id,
         };
 
         Ok(Response::new(response))

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,

proto/character.proto

@@ -4,6 +4,9 @@ package character;
 
 service CharacterService {
     rpc GetCharacterList(GetCharacterListRequest) returns (GetCharacterListResponse);
+    rpc CreateCharacter(CreateCharacterRequest) returns (Empty);
+    rpc DeleteCharacter(DeleteCharacterRequest) returns (Empty);
+    rpc GetCharacter(GetCharacterRequest) returns (Empty);
 }
 
 message GetCharacterListRequest {
@@ -14,6 +17,19 @@ message GetCharacterListResponse {
     repeated Character characters = 1;
 }
 
+message CreateCharacterRequest {
+    string user_id = 1;
+}
+
+message DeleteCharacterRequest {
+    string user_id = 1;
+    string char_id = 2;
+}
+
+message GetCharacterRequest {
+    string user_id = 1;
+}
+
 message Character {
     string character_id = 1; // Unique ID for the character
     string name = 2;         // Name of the character
@@ -32,4 +48,6 @@ message EquippedItem {
     int32 gem_option = 2;
     int32 socket = 3;
     int32 grade = 4;
-}
+}
+
+message Empty {}

proto/character_db_api.proto

@@ -3,8 +3,9 @@ syntax = "proto3";
 package character_db_api;
 
 service CharacterService {
-    rpc GetCharacter (CharacterRequest) returns (CharacterResponse);
-    rpc CreateCharacter (CreateCharacterRequest) returns (CharacterResponse);
+    rpc GetCharacter (CharacterRequest) returns (Character);
+    rpc GetCharacterList (CharacterListRequest) returns (CharacterListResponse);
+    rpc CreateCharacter (CreateCharacterRequest) returns (CreateCharacterResponse);
     rpc DeleteCharacter (DeleteCharacterRequest) returns (Empty);
 }
 
@@ -12,6 +13,14 @@ message CharacterRequest {
     int32 character_id = 1;
 }
 
+message CharacterListRequest {
+    int32 user_id = 1;
+}
+
+message CharacterListResponse {
+    repeated Character characters = 1;
+}
+
 message CreateCharacterRequest {
     int32 user_id = 1;
     string name = 2;
@@ -21,11 +30,15 @@ message CreateCharacterRequest {
     string position = 6;  // JSON serialized
 }
 
+message CreateCharacterResponse {
+    int32 character_id = 1;
+}
+
 message DeleteCharacterRequest {
     int32 character_id = 1;
 }
 
-message CharacterResponse {
+message Character {
     int32 id = 1;
     int32 user_id = 2;
     string name = 3;