pushing

gameserver/src/logic/game/account.rs

@@ -0,0 +1,62 @@
+use database::{db, models::game::user_info::UserInfo, models::user::account::Account};
+use sqlx::SqlitePool;
+use tracing::info;
+
+#[derive(Debug, thiserror::Error)]
+pub enum LoginError {
+    #[error("Invalid access token")]
+    InvalidToken,
+    #[error("Database error: {0}")]
+    Database(#[from] sqlx::Error),
+}
+
+/// Parse UID from access token (format: "uid|other_data")
+pub fn parse_uid_from_token(token: &str) -> Result<i64, LoginError> {
+    token
+        .split('|')
+        .next()
+        .and_then(|s| s.parse().ok())
+        .ok_or(LoginError::InvalidToken)
+}
+
+/// Get or create user, returning both account and user info
+pub async fn get_or_create_user(
+    pool: &SqlitePool,
+    uid: i64,
+) -> Result<(Account, UserInfo), LoginError> {
+    // Use the database layer's get_or_create_user which handles the mapping
+    let (account, user_info) = db::user::get_or_create_user(pool, uid).await?;
+
+    info!("User logged in: {}", account.user_name);
+    Ok((account, user_info))
+}
+
+/// Update user's return status timestamp
+pub async fn update_login_timestamp(pool: &SqlitePool, uid: i64) -> Result<(), LoginError> {
+    let now_ms = chrono::Utc::now().timestamp_millis();
+    db::user::update_return_status(pool, uid, now_ms).await?;
+    info!("Updated return status for UID {} to {}", uid, now_ms);
+    Ok(())
+}
+
+pub async fn get_owner_index_for_uid(pool: &SqlitePool, uid: i64) -> Result<i64, LoginError> {
+    let owner_index = sqlx::query_scalar::<_, i64>("SELECT OwnerIndex FROM UserInfo WHERE Uid = ?")
+        .bind(uid)
+        .fetch_one(pool)
+        .await?;
+
+    Ok(owner_index)
+}
+
+/// Get UID for a given owner_index from UserMapper table
+pub async fn get_uid_for_owner_index(
+    pool: &SqlitePool,
+    owner_index: i64,
+) -> Result<i64, LoginError> {
+    let uid = sqlx::query_scalar::<_, i64>("SELECT Uid FROM UserInfo WHERE OwnerIndex = ?")
+        .bind(owner_index)
+        .fetch_one(pool)
+        .await?;
+
+    Ok(uid)
+}

gameserver/src/logic/game/achievement_clear.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{AchievementClearRequest, AchievementClearResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: AchievementClearRequest) -> GameResponse {
+    info!("Handling AchievementClearRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = AchievementClearResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::AchievementClear.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/achievement_info.rs

@@ -0,0 +1,54 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    AchievementDbInfo, AchievementInfoRequest, AchievementInfoResponse, Notify,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::achievement_info::get_achievement_info;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, req: AchievementInfoRequest) -> GameResponse {
+    info!("Handling AchievementInfoRequest: {:?}", req);
+
+    let achievements = match get_achievement_info(pool, uid).await {
+        Ok(list) => list,
+        Err(err) => {
+            eprintln!("get_achievement_info failed: {:?}", err);
+            vec![]
+        }
+    };
+
+    let achievement_info = achievements
+        .into_iter()
+        .map(|a| AchievementDbInfo {
+            group_id: a.group_id,
+            value: a.value,
+            max_clear_id: a.max_clear_id,
+            contents_group: a.contents_group,
+        })
+        .collect();
+
+    let response = AchievementInfoResponse {
+        achievement_info,
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::AchievementInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/achievement_update.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{AchievementUpdateRequest, AchievementUpdateResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: AchievementUpdateRequest) -> GameResponse {
+    info!("Handling AchievementUpdateRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = AchievementUpdateResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::AchievementUpdate.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/active_map.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{ActiveMapRequest, ActiveMapResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: ActiveMapRequest) -> GameResponse {
+    info!("Handling ActiveMapRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = ActiveMapResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/alchemy.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{AlchemyRequest, AlchemyResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: AlchemyRequest) -> GameResponse {
+    info!("Handling AlchemyRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = AlchemyResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::Alchemy.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/alchemy_batch.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{AlchemyBatchRequest, AlchemyBatchResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: AlchemyBatchRequest) -> GameResponse {
+    info!("Handling AlchemyBatchRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = AlchemyBatchResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::AlchemyBatch.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/all_char_refresh.rs

@@ -0,0 +1,46 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    AllCharRefreshRequest, AllCharRefreshResponse, DefineCharStatOption, Notify,
+    PictorialBuffStatDbInfo,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: AllCharRefreshRequest) -> GameResponse {
+    info!("Handling AllCharRefreshRequest: {:?}", req);
+
+    let buff_stat_info: Vec<PictorialBuffStatDbInfo> = vec![
+        PictorialBuffStatDbInfo {
+            stat_type: Some(DefineCharStatOption::HealthPercent as i32),
+            stat_value: Some(0.0125),
+        },
+        PictorialBuffStatDbInfo {
+            stat_type: Some(DefineCharStatOption::AttackPercent as i32),
+            stat_value: Some(0.0096),
+        },
+    ];
+
+    let response = AllCharRefreshResponse {
+        buff_stat_info,
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    // Notify same as others
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2],
+        active_contents_info: vec![],
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8916),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::AllCharRefresh.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/attendance.rs

@@ -0,0 +1,85 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    AttendanceAlwaysInfo, AttendanceEventRewardObtainInfo, AttendanceLimitInfo, AttendanceRequest,
+    AttendanceResponse, Notify, SubscribeAttendanceInfo,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::attendance_always_info::get_attendance_always_info;
+use database::db::attendance_event_reward_obtain_info::get_attendance_event_reward_obtain_info;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, req: AttendanceRequest) -> GameResponse {
+    info!("Handling AttendanceRequest: {:?}", req);
+
+    let always_info = get_attendance_always_info(pool, uid)
+        .await
+        .unwrap_or_default();
+
+    let event_rewards = get_attendance_event_reward_obtain_info(pool, uid)
+        .await
+        .unwrap_or_default();
+
+    let subscribe_info: Vec<SubscribeAttendanceInfo> = vec![];
+    let _limit_info: Vec<AttendanceLimitInfo> = vec![];
+
+    // --- Map DB models → Protobuf types ---
+    let attendance_always_info = always_info
+        .into_iter()
+        .map(|a| AttendanceAlwaysInfo {
+            event_schedule_id: a.event_schedule_id,
+            attendance_group_id: a.attendance_group_id,
+            attendance_count: a.attendance_count,
+        })
+        .collect::<Vec<_>>();
+
+    let attendance_event_reward_obtain_info = event_rewards
+        .into_iter()
+        .map(|r| AttendanceEventRewardObtainInfo {
+            event_schedule_id: r.event_schedule_id,
+            group_id: r.group_id,
+            id: r.id,
+        })
+        .collect::<Vec<_>>();
+
+    let subscribe_attendance_info = subscribe_info
+        .into_iter()
+        .map(|s| SubscribeAttendanceInfo {
+            ticket_id: s.ticket_id,
+            reserved_date: s.reserved_date,
+            expiry_date: s.expiry_date,
+        })
+        .collect::<Vec<_>>();
+
+    let response = AttendanceResponse {
+        attendance_always_info,
+        attendance_limit_info: vec![], // currently unused
+        standard_attendance_info: vec![],
+        premium_attendance_info: vec![],
+        monthly1_attendance_info: vec![],
+        monthly2_attendance_info: vec![],
+        subscribe_attendance_info,
+        attendance_package_info: vec![],
+        attendance_event_reward_obtain_info,
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/balance_version_check.rs

@@ -0,0 +1,30 @@
+use bd2::proto::proto_net::{BalanceVersionCheckRequest, BalanceVersionCheckResponse, Notify};
+use crypto::network::GameResponse;
+use tracing::info;
+use bd2::prost::Message;
+use common::packet_code::PacketCodeType;
+
+pub async fn handle(req: BalanceVersionCheckRequest) -> GameResponse {
+    info!("Handling balance version check request: {:?}", req);
+
+    let response = BalanceVersionCheckResponse {};
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::BalanceVersionCheck.info();
+
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_end.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleEndRequest, BattleEndResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleEndRequest) -> GameResponse {
+    info!("Handling BattleEndRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleEndResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleEnd.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_end_test.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleEndTestRequest, BattleEndTestResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleEndTestRequest) -> GameResponse {
+    info!("Handling BattleEndTestRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleEndTestResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleEndTest.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_enter.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleEnterRequest, BattleEnterResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleEnterRequest) -> GameResponse {
+    info!("Handling BattleEnterRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleEnterResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleEnter.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_exit.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleExitRequest, BattleExitResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleExitRequest) -> GameResponse {
+    info!("Handling BattleExitRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleExitResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleExit.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_give_up.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleGiveUpRequest, BattleGiveUpResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleGiveUpRequest) -> GameResponse {
+    info!("Handling BattleGiveUpRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleGiveUpResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleGiveUp.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_retry.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleRetryRequest, BattleRetryResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleRetryRequest) -> GameResponse {
+    info!("Handling BattleRetryRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleRetryResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleRetry.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_retry_previous_turn.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleRetryPreviousTurnRequest, BattleRetryPreviousTurnResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleRetryPreviousTurnRequest) -> GameResponse {
+    info!("Handling BattleRetryPreviousTurnRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleRetryPreviousTurnResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleRetryPreviousTurn.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_start.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleStartRequest, BattleStartResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleStartRequest) -> GameResponse {
+    info!("Handling BattleStartRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleStartResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleStart.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/battle_verify_state.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{BattleVerifyStateRequest, BattleVerifyStateResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: BattleVerifyStateRequest) -> GameResponse {
+    info!("Handling BattleVerifyStateRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = BattleVerifyStateResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::BattleVerifyState.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_cumulative_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaCumulativeRewardRequest, CafeteriaCumulativeRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaCumulativeRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaCumulativeRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaCumulativeRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaCumulativeReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_daily_connection_costume_refresh.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaDailyConnectionCostumeRefreshRequest, CafeteriaDailyConnectionCostumeRefreshResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaDailyConnectionCostumeRefreshRequest) -> GameResponse {
+    info!("Handling CafeteriaDailyConnectionCostumeRefreshRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaDailyConnectionCostumeRefreshResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaDailyConnectionCostumeRefresh.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_event_npc_interaction_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaEventNpcInteractionRewardRequest, CafeteriaEventNpcInteractionRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaEventNpcInteractionRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaEventNpcInteractionRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaEventNpcInteractionRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaEventNpcInteractionReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaInfoRequest, CafeteriaInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaInfoRequest) -> GameResponse {
+    info!("Handling CafeteriaInfoRequest: {:?}", req);
+
+    let response = CafeteriaInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CafeteriaInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_introduction_story_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaIntroductionStoryRewardRequest, CafeteriaIntroductionStoryRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaIntroductionStoryRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaIntroductionStoryRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaIntroductionStoryRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaIntroductionStoryReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_level_up.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaLevelUpRequest, CafeteriaLevelUpResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaLevelUpRequest) -> GameResponse {
+    info!("Handling CafeteriaLevelUpRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaLevelUpResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaLevelUp.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_manage_item_add.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaManageItemAddRequest, CafeteriaManageItemAddResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaManageItemAddRequest) -> GameResponse {
+    info!("Handling CafeteriaManageItemAddRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaManageItemAddResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaManageItemAdd.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_rare_npc_interaction_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRareNpcInteractionRewardRequest, CafeteriaRareNpcInteractionRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRareNpcInteractionRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaRareNpcInteractionRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRareNpcInteractionRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRareNpcInteractionReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_regular_costume_interaction_all_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRegularCostumeInteractionAllRewardRequest, CafeteriaRegularCostumeInteractionAllRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRegularCostumeInteractionAllRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaRegularCostumeInteractionAllRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRegularCostumeInteractionAllRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRegularCostumeInteractionAllReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_regular_costume_interaction_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRegularCostumeInteractionRewardRequest, CafeteriaRegularCostumeInteractionRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRegularCostumeInteractionRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaRegularCostumeInteractionRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRegularCostumeInteractionRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRegularCostumeInteractionReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_regular_costume_note_all_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRegularCostumeNoteAllRewardRequest, CafeteriaRegularCostumeNoteAllRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRegularCostumeNoteAllRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaRegularCostumeNoteAllRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRegularCostumeNoteAllRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRegularCostumeNoteAllReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_regular_costume_note_info.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRegularCostumeNoteInfoRequest, CafeteriaRegularCostumeNoteInfoResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRegularCostumeNoteInfoRequest) -> GameResponse {
+    info!("Handling CafeteriaRegularCostumeNoteInfoRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRegularCostumeNoteInfoResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRegularCostumeNoteInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_regular_costume_note_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRegularCostumeNoteRewardRequest, CafeteriaRegularCostumeNoteRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRegularCostumeNoteRewardRequest) -> GameResponse {
+    info!("Handling CafeteriaRegularCostumeNoteRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRegularCostumeNoteRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRegularCostumeNoteReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_reward_receipt_time_update_using_cheat.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaRewardReceiptTimeUpdateUsingCheatRequest, CafeteriaRewardReceiptTimeUpdateUsingCheatResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaRewardReceiptTimeUpdateUsingCheatRequest) -> GameResponse {
+    info!("Handling CafeteriaRewardReceiptTimeUpdateUsingCheatRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaRewardReceiptTimeUpdateUsingCheatResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaRewardReceiptTimeUpdateUsingCheat.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_spawn_reset.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CafeteriaSpawnResetRequest, CafeteriaSpawnResetResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CafeteriaSpawnResetRequest) -> GameResponse {
+    info!("Handling CafeteriaSpawnResetRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CafeteriaSpawnResetResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CafeteriaSpawnReset.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cafeteria_spawn_reset_cheat.rs

@@ -0,0 +1,49 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    CafeteriaSpawnResetCheatRequest, CafeteriaSpawnResetCheatResponse, Notify,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(
+    _pool: &SqlitePool,
+    _uid: i64,
+    req: CafeteriaSpawnResetCheatRequest,
+) -> GameResponse {
+    info!("Handling CafeteriaSpawnResetCheatRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = CafeteriaSpawnResetCheatResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cancel_leave_user.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CancelLeaveUserRequest, CancelLeaveUserResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CancelLeaveUserRequest) -> GameResponse {
+    info!("Handling CancelLeaveUserRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CancelLeaveUserResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CancelLeaveUser.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cash_mail_info.rs

@@ -0,0 +1,36 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CashMailInfoRequest, CashMailInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CashMailInfoRequest) -> GameResponse {
+    info!("Handling CashMailInfoRequest: {:?}", req);
+
+    let mail_info = vec![];
+
+    let response = CashMailInfoResponse {
+        mail_info,
+        total_count: Some(0),
+        max_inven_index: Some(0),
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CashMailInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cash_shop_buy.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CashShopBuyRequest, CashShopBuyResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CashShopBuyRequest) -> GameResponse {
+    info!("Handling CashShopBuyRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CashShopBuyResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CashShopBuy.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cash_shop_info.rs

@@ -0,0 +1,86 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CashProductDbInfo, CashShopInfoRequest, CashShopInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use serde_json::Value;
+use tracing::info;
+
+pub async fn handle(
+    _pool: &sqlx::SqlitePool,
+    _uid: i64,
+    _req: CashShopInfoRequest,
+) -> GameResponse {
+    info!("Handling CashShopInfoRequest");
+
+    // Load the JSON file from starter data
+    let data: Value =
+        serde_json::from_str(include_str!("../../../../data/starter/cash_shop_info.json"))
+            .expect("Failed to parse cash_shop_info.json");
+
+    let products = data
+        .get("productInfo")
+        .and_then(|v| v.as_array())
+        .cloned()
+        .unwrap_or_default();
+
+    let mut product_info = Vec::new();
+
+    for p in products {
+        product_info.push(CashProductDbInfo {
+            group_id: p.get("groupId").and_then(|v| v.as_i64()).map(|v| v as i32),
+            id: p.get("id").and_then(|v| v.as_i64()).map(|v| v as i32),
+            sale_group: p
+                .get("saleGroup")
+                .and_then(|v| v.as_i64())
+                .map(|v| v as i32),
+            start_time: p.get("startTime").and_then(|v| v.as_i64()),
+            end_time: p.get("endTime").and_then(|v| v.as_i64()),
+            end_delay_minutes: p
+                .get("endDelayMinutes")
+                .and_then(|v| v.as_i64())
+                .map(|v| v as i32),
+            event_index: p.get("eventIndex").and_then(|v| v.as_i64()),
+            ..Default::default()
+        });
+    }
+
+    // Parse reset times
+    let daily_reset_time = data
+        .get("dailyResetTime")
+        .and_then(|v| v.as_i64())
+        .unwrap_or_default();
+    let weekly_reset_time = data
+        .get("weeklyResetTime")
+        .and_then(|v| v.as_i64())
+        .unwrap_or_default();
+    let monthly_reset_time = data
+        .get("monthlyResetTime")
+        .and_then(|v| v.as_i64())
+        .unwrap_or_default();
+
+    let response = CashShopInfoResponse {
+        product_info,
+        daily_reset_time: Some(daily_reset_time),
+        weekly_reset_time: Some(weekly_reset_time),
+        monthly_reset_time: Some(monthly_reset_time),
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CashShopInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cash_shop_purchase_count_info.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CashShopPurchaseCountInfoRequest, CashShopPurchaseCountInfoResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CashShopPurchaseCountInfoRequest) -> GameResponse {
+    info!("Handling CashShopPurchaseCountInfoRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CashShopPurchaseCountInfoResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CashShopPurchaseCountInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_all_revival.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharAllRevivalRequest, CharAllRevivalResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharAllRevivalRequest) -> GameResponse {
+    info!("Handling CharAllRevivalRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharAllRevivalResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharAllRevival.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_auto_revive_set.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharAutoReviveSetRequest, CharAutoReviveSetResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharAutoReviveSetRequest) -> GameResponse {
+    info!("Handling CharAutoReviveSetRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = CharAutoReviveSetResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_awake_active.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharAwakeActiveRequest, CharAwakeActiveResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharAwakeActiveRequest) -> GameResponse {
+    info!("Handling CharAwakeActiveRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharAwakeActiveResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharAwakeActive.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_awake_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharAwakeInfoRequest, CharAwakeInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharAwakeInfoRequest) -> GameResponse {
+    info!("Handling CharAwakeInfoRequest: {:?}", req);
+
+    let response = CharAwakeInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_class_up.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharClassUpRequest, CharClassUpResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharClassUpRequest) -> GameResponse {
+    info!("Handling CharClassUpRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharClassUpResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharClassUp.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_expiry.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharExpiryRequest, CharExpiryResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharExpiryRequest) -> GameResponse {
+    info!("Handling CharExpiryRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharExpiryResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharExpiry.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_growth.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharGrowthRequest, CharGrowthResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharGrowthRequest) -> GameResponse {
+    info!("Handling CharGrowthRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharGrowthResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharGrowth.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_healing.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharHealingRequest, CharHealingResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharHealingRequest) -> GameResponse {
+    info!("Handling CharHealingRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharHealingResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharHealing.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_immortal.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharImmortalRequest, CharImmortalResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharImmortalRequest) -> GameResponse {
+    info!("Handling CharImmortalRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharImmortalResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharImmortal.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_imprint_level_up.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharImprintLevelUpRequest, CharImprintLevelUpResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharImprintLevelUpRequest) -> GameResponse {
+    info!("Handling CharImprintLevelUpRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharImprintLevelUpResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharImprintLevelUp.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_info.rs

@@ -0,0 +1,62 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharDbInfo, CharInfoRequest, CharInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::char_info::get_char_info;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, req: CharInfoRequest) -> GameResponse {
+    info!("Handling CharInfoRequest: {:?}", req);
+
+    let char_rows = match get_char_info(pool, uid).await {
+        Ok(rows) => rows,
+        Err(err) => {
+            eprintln!("get_char_info error: {:?}", err);
+            vec![]
+        }
+    };
+
+    let char_info = char_rows
+        .into_iter()
+        .map(|row| CharDbInfo {
+            inven_index: row.inven_index,
+            id: row.id,
+            hp: row.hp,
+            level: row.level,
+            costume_id: row.costume_id,
+            exp: row.exp,
+            use_costume: row.use_costume,
+            talent_level: row.talent_level,
+            talent_exp: row.talent_exp,
+            solidarity_reward: row.solidarity_reward,
+            expiry_time: row.expiry_time,
+            connect_potential_costume: row.connect_potential_costume,
+            pictorialbook_info: vec![], // empty
+        })
+        .collect::<Vec<_>>();
+
+    let response = CharInfoResponse {
+        char_info,
+        field_char_control_deck_type: Some(0),
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CharInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_level_up.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharLevelUpRequest, CharLevelUpResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharLevelUpRequest) -> GameResponse {
+    info!("Handling CharLevelUpRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharLevelUpResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharLevelUp.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_partner_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharPartnerInfoRequest, CharPartnerInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharPartnerInfoRequest) -> GameResponse {
+    info!("Handling CharPartnerInfoRequest: {:?}", req);
+
+    let response = CharPartnerInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CharPartnerInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_partner_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharPartnerRewardRequest, CharPartnerRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharPartnerRewardRequest) -> GameResponse {
+    info!("Handling CharPartnerRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharPartnerRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharPartnerReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_partner_story_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharPartnerStoryRewardRequest, CharPartnerStoryRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharPartnerStoryRewardRequest) -> GameResponse {
+    info!("Handling CharPartnerStoryRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharPartnerStoryRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharPartnerStoryReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_scout_info.rs

@@ -0,0 +1,37 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharScoutInfoRequest, CharScoutInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharScoutInfoRequest) -> GameResponse {
+    info!("Handling CharScoutInfoRequest: {:?}", req);
+
+    let appear_char_id = vec![6300, 6200];
+
+    let response = CharScoutInfoResponse {
+        appear_char_id,
+        scout_complete_char_id: vec![],
+        use_reset_count: Some(0),
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_special_scout_buy.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharSpecialScoutBuyRequest, CharSpecialScoutBuyResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharSpecialScoutBuyRequest) -> GameResponse {
+    info!("Handling CharSpecialScoutBuyRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharSpecialScoutBuyResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharSpecialScoutBuy.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/char_special_scout_reset.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CharSpecialScoutResetRequest, CharSpecialScoutResetResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CharSpecialScoutResetRequest) -> GameResponse {
+    info!("Handling CharSpecialScoutResetRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CharSpecialScoutResetResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CharSpecialScoutReset.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/charge_cost_info.rs

@@ -0,0 +1,173 @@
+use bd2::proto::proto_net::{
+    ChargeCostEventScheduleDbInfo, ChargeCostInfoRequest, ChargeCostInfoResponse, CostTimeDbInfo,
+    ItemDbInfo, Notify,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::charge_cost_event_schedule_info::get_charge_cost_event_schedule_info;
+use database::models::game::charge_cost_event_schedule_info::ChargeCostEventScheduleInfo;
+use prost::Message;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, req: ChargeCostInfoRequest) -> GameResponse {
+    info!("Handling ChargeCostInfoRequest for uid: {}", uid);
+
+    // Load all cost-time entries for this user
+    let all_cost_time_info = get_cost_time_with_items(pool, uid)
+        .await
+        .unwrap_or_default();
+
+    // Make a lookup map: type -> CostTimeDbInfo
+    use std::collections::HashMap;
+    let mut by_type: HashMap<i32, CostTimeDbInfo> = HashMap::new();
+    for entry in all_cost_time_info {
+        if let Some(ref item) = entry.cost_item_info {
+            if let Some(t) = item.r#type {
+                by_type.insert(t, entry);
+            }
+        }
+    }
+
+    // Build cost_time_info in the same order as request.element_type
+    let mut cost_time_info = Vec::new();
+    for t in &req.element_type {
+        if let Some(entry) = by_type.get(t) {
+            cost_time_info.push(entry.clone());
+        } else {
+            // Fallback if type missing in DB
+            cost_time_info.push(CostTimeDbInfo {
+                last_charge_time: Some(0),
+                cost_item_info: Some(ItemDbInfo {
+                    inven_index: None,
+                    id: None,
+                    r#type: Some(*t),
+                    count: Some(0),
+                    keep_flag: None,
+                    time_value: None,
+                    pictorialbook_info: None,
+                    expiry_time: None,
+                    sort_id: None,
+                    use_count: None,
+                }),
+            });
+        }
+    }
+
+    // Load event schedule info
+    let db_sched = get_charge_cost_event_schedule_info(pool, uid)
+        .await
+        .unwrap_or_default();
+
+    let event_schedule_info = map_event_schedule(db_sched);
+
+    // Build protobuf response
+    let response = ChargeCostInfoResponse {
+        cost_time_info,
+        event_schedule_info,
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8916),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::ChargeCostInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}
+
+// New function to JOIN CostTimeInfo with ItemInfo
+async fn get_cost_time_with_items(
+    pool: &SqlitePool,
+    uid: i64,
+) -> sqlx::Result<Vec<CostTimeDbInfo>> {
+    #[derive(sqlx::FromRow)]
+    struct CostTimeWithItem {
+        last_charge_time: i64,
+        // Item fields
+        inven_index: Option<i64>,
+        id: Option<i32>,
+        r#type: Option<i32>,
+        count: Option<i32>,
+        keep_flag: Option<i32>,
+        time_value: Option<i64>,
+        expiry_time: Option<i64>,
+        sort_id: Option<i32>,
+        use_count: Option<i32>,
+    }
+
+    let rows = sqlx::query_as::<_, CostTimeWithItem>(
+        r#"
+        SELECT
+            c.LastChargeTime as last_charge_time,
+            i.InvenIndex as inven_index,
+            i.Id as id,
+            i.Type as type,
+            i.Count as count,
+            i.KeepFlag as keep_flag,
+            i.TimeValue as time_value,
+            i.ExpiryTime as expiry_time,
+            i.SortId as sort_id,
+            i.UseCount as use_count
+        FROM CostTimeInfo c
+        LEFT JOIN CostItemInfo i ON c.CostItemInfoIndex = i.InvenIndex AND c.Uid = i.Uid
+        WHERE c.Uid = ?
+        "#,
+    )
+    .bind(uid)
+    .fetch_all(pool)
+    .await?;
+
+    let result = rows
+        .into_iter()
+        .map(|r| {
+            let item = if r.inven_index.is_some() {
+                Some(ItemDbInfo {
+                    inven_index: r.inven_index,
+                    id: r.id,
+                    r#type: r.r#type,
+                    count: r.count,
+                    keep_flag: r.keep_flag,
+                    time_value: r.time_value,
+                    pictorialbook_info: None,
+                    expiry_time: r.expiry_time,
+                    sort_id: r.sort_id,
+                    use_count: r.use_count,
+                })
+            } else {
+                None
+            };
+
+            CostTimeDbInfo {
+                last_charge_time: Some(r.last_charge_time),
+                cost_item_info: item,
+            }
+        })
+        .collect();
+
+    Ok(result)
+}
+
+fn map_event_schedule(
+    rows: Vec<ChargeCostEventScheduleInfo>,
+) -> Vec<ChargeCostEventScheduleDbInfo> {
+    rows.into_iter()
+        .map(|r| ChargeCostEventScheduleDbInfo {
+            schedule_index: r.schedule_index,
+            item_type: r.item_type,
+            max_count: r.max_count,
+            start_time: r.start_time,
+            end_time: r.end_time,
+        })
+        .collect()
+}

gameserver/src/logic/game/clear_package_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{ClearPackageRewardRequest, ClearPackageRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: ClearPackageRewardRequest) -> GameResponse {
+    info!("Handling ClearPackageRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = ClearPackageRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::ClearPackageReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/client_custom_log.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{ClientCustomLogRequest, ClientCustomLogResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: ClientCustomLogRequest) -> GameResponse {
+    info!("Handling ClientCustomLogRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = ClientCustomLogResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::ClientCustomLog.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/community_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CommunityRewardRequest, CommunityRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CommunityRewardRequest) -> GameResponse {
+    info!("Handling CommunityRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CommunityRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CommunityReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/community_reward_info.rs

@@ -0,0 +1,36 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CommunityRewardInfoRequest, CommunityRewardInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(
+    _pool: &SqlitePool,
+    _uid: i64,
+    req: CommunityRewardInfoRequest,
+) -> GameResponse {
+    info!("Handling CommunityRewardInfoRequest: {:?}", req);
+
+    let response = CommunityRewardInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CommunityRewardInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cooking.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CookingRequest, CookingResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CookingRequest) -> GameResponse {
+    info!("Handling CookingRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CookingResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::Cooking.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/cooking_research.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CookingResearchRequest, CookingResearchResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CookingResearchRequest) -> GameResponse {
+    info!("Handling CookingResearchRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CookingResearchResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CookingResearch.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_all_rounder_upgrade.rs

@@ -0,0 +1,49 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    CostumeAllRounderUpgradeRequest, CostumeAllRounderUpgradeResponse, Notify,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(
+    _pool: &SqlitePool,
+    _uid: i64,
+    req: CostumeAllRounderUpgradeRequest,
+) -> GameResponse {
+    info!("Handling CostumeAllRounderUpgradeRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = CostumeAllRounderUpgradeResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_clear.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumeClearRequest, CostumeClearResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CostumeClearRequest) -> GameResponse {
+    info!("Handling CostumeClearRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = CostumeClearResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_info.rs

@@ -0,0 +1,77 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumeDbInfo, CostumeInfoRequest, CostumeInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::costume_info::get_costume_info;
+use serde_json;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, req: CostumeInfoRequest) -> GameResponse {
+    info!("Handling CostumeInfoRequest: {:?}", req);
+
+    let costume_rows = match get_costume_info(pool, uid).await {
+        Ok(rows) => rows,
+        Err(err) => {
+            eprintln!("get_costume_info error: {:?}", err);
+            vec![]
+        }
+    };
+
+    let costume_info = costume_rows
+        .into_iter()
+        .filter_map(|row| {
+            // Ensure the ID is valid
+            let id = row.id?;
+            if id == 0 {
+                eprintln!(
+                    "Skipping costume with id=0 (invenIndex={:?}, uid={})",
+                    row.inven_index, row.uid
+                );
+                return None;
+            }
+
+            //aParse PotentialId JSON -> Vec<i32>
+            let parsed_potential_ids: Vec<i32> = row
+                .potential_id
+                .as_deref()
+                .and_then(|s| serde_json::from_str::<Vec<i32>>(s).ok())
+                .unwrap_or_default();
+
+            Some(CostumeDbInfo {
+                inven_index: row.inven_index,
+                id: Some(id),
+                level: row.level,
+                use_char: row.use_char,
+                sort_id: row.sort_id,
+                use_my_room_count: row.use_my_room_count,
+                potential_id: parsed_potential_ids,
+                pictorialbook_info: vec![],
+                design_id: row.design_id,
+            })
+        })
+        .collect::<Vec<_>>();
+
+    let response = CostumeInfoResponse {
+        costume_info,
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::CostumeInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_node_activation.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumeNodeActivationRequest, CostumeNodeActivationResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CostumeNodeActivationRequest) -> GameResponse {
+    info!("Handling CostumeNodeActivationRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CostumeNodeActivationResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CostumeNodeActivation.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_potential_connect.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumePotentialConnectRequest, CostumePotentialConnectResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CostumePotentialConnectRequest) -> GameResponse {
+    info!("Handling CostumePotentialConnectRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CostumePotentialConnectResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CostumePotentialConnect.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_upgrade.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumeUpgradeRequest, CostumeUpgradeResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CostumeUpgradeRequest) -> GameResponse {
+    info!("Handling CostumeUpgradeRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CostumeUpgradeResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CostumeUpgrade.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/costume_use.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{CostumeUseRequest, CostumeUseResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: CostumeUseRequest) -> GameResponse {
+    info!("Handling CostumeUseRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = CostumeUseResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::CostumeUse.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/dating_episode_clear.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DatingEpisodeClearRequest, DatingEpisodeClearResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DatingEpisodeClearRequest) -> GameResponse {
+    info!("Handling DatingEpisodeClearRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = DatingEpisodeClearResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::DatingEpisodeClear.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/dating_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DatingInfoRequest, DatingInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DatingInfoRequest) -> GameResponse {
+    info!("Handling DatingInfoRequest: {:?}", req);
+
+    let response = DatingInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::DatingInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/dating_message_update.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DatingMessageUpdateRequest, DatingMessageUpdateResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DatingMessageUpdateRequest) -> GameResponse {
+    info!("Handling DatingMessageUpdateRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = DatingMessageUpdateResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::DatingMessageUpdate.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/deck_char_auto_revive.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DeckCharAutoReviveRequest, DeckCharAutoReviveResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DeckCharAutoReviveRequest) -> GameResponse {
+    info!("Handling DeckCharAutoReviveRequest: {:?}", req);
+
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+
+    let response = DeckCharAutoReviveResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/deck_costume_setting_info.rs

@@ -0,0 +1,38 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{
+    DeckCostumeSettingInfoRequest, DeckCostumeSettingInfoResponse, Notify,
+};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(
+    _pool: &SqlitePool,
+    _uid: i64,
+    req: DeckCostumeSettingInfoRequest,
+) -> GameResponse {
+    info!("Handling DeckCostumeSettingInfoRequest: {:?}", req);
+
+    let response = DeckCostumeSettingInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/deck_costume_setting_save.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DeckCostumeSettingSaveRequest, DeckCostumeSettingSaveResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DeckCostumeSettingSaveRequest) -> GameResponse {
+    info!("Handling DeckCostumeSettingSaveRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = DeckCostumeSettingSaveResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::DeckCostumeSettingSave.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/deck_info.rs

@@ -0,0 +1,58 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DeckDbInfo, DeckInfoRequest, DeckInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use database::db::deck_info::get_deck_info;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(pool: &SqlitePool, uid: i64, _req: DeckInfoRequest) -> GameResponse {
+    info!("Handling DeckInfoRequest for uid: {}", uid);
+
+    // Fetch deck info from DB
+    let deck_infos = match get_deck_info(pool, uid).await {
+        Ok(list) => list,
+        Err(err) => {
+            eprintln!("Error fetching DeckInfo: {:?}", err);
+            vec![]
+        }
+    };
+
+    // Map DB model → protobuf structure
+    let deck_info_proto: Vec<DeckDbInfo> = deck_infos
+        .into_iter()
+        .map(|d| DeckDbInfo {
+            char_inven_index: d.char_inven_index,
+            position: d.position,
+            sequence: d.sequence,
+        })
+        .collect();
+
+    // Talent slot info (defaults to 4 slots = 0)
+    let talent_slot_info = vec![0, 0, 0, 0];
+
+    // Construct final response
+    let response = DeckInfoResponse {
+        deck_info: deck_info_proto,
+        talent_slot_info,
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::DeckInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/deck_save.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DeckSaveRequest, DeckSaveResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DeckSaveRequest) -> GameResponse {
+    info!("Handling DeckSaveRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = DeckSaveResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::DeckSave.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/dispatch_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DispatchInfoRequest, DispatchInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DispatchInfoRequest) -> GameResponse {
+    info!("Handling DispatchInfoRequest: {:?}", req);
+
+    let response = DispatchInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::Common.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/dispatch_reward.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{DispatchRewardRequest, DispatchRewardResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: DispatchRewardRequest) -> GameResponse {
+    info!("Handling DispatchRewardRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = DispatchRewardResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::DispatchReward.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/eat_food.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EatFoodRequest, EatFoodResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EatFoodRequest) -> GameResponse {
+    info!("Handling EatFoodRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EatFoodResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EatFood.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/eat_food_auto.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EatFoodAutoRequest, EatFoodAutoResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EatFoodAutoRequest) -> GameResponse {
+    info!("Handling EatFoodAutoRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EatFoodAutoResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EatFoodAuto.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_add_slot.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipAddSlotRequest, EquipAddSlotResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipAddSlotRequest) -> GameResponse {
+    info!("Handling EquipAddSlotRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipAddSlotResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipAddSlot.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_batch_use.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipBatchUseRequest, EquipBatchUseResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipBatchUseRequest) -> GameResponse {
+    info!("Handling EquipBatchUseRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipBatchUseResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipBatchUse.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_break.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipBreakRequest, EquipBreakResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipBreakRequest) -> GameResponse {
+    info!("Handling EquipBreakRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipBreakResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipBreak.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_change.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipChangeRequest, EquipChangeResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipChangeRequest) -> GameResponse {
+    info!("Handling EquipChangeRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipChangeResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipChange.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_clear.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipClearRequest, EquipClearResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipClearRequest) -> GameResponse {
+    info!("Handling EquipClearRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipClearResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipClear.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_from_making_to_break.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipFromMakingToBreakRequest, EquipFromMakingToBreakResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipFromMakingToBreakRequest) -> GameResponse {
+    info!("Handling EquipFromMakingToBreakRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipFromMakingToBreakResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipFromMakingToBreak.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_from_making_to_upgrade.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipFromMakingToUpgradeRequest, EquipFromMakingToUpgradeResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipFromMakingToUpgradeRequest) -> GameResponse {
+    info!("Handling EquipFromMakingToUpgradeRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipFromMakingToUpgradeResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipFromMakingToUpgrade.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_from_upgrade_to_break.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipFromUpgradeToBreakRequest, EquipFromUpgradeToBreakResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipFromUpgradeToBreakRequest) -> GameResponse {
+    info!("Handling EquipFromUpgradeToBreakRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipFromUpgradeToBreakResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipFromUpgradeToBreak.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_info.rs

@@ -0,0 +1,32 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipInfoRequest, EquipInfoResponse, Notify};
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipInfoRequest) -> GameResponse {
+    info!("Handling EquipInfoRequest {:?}", req);
+
+    let response = EquipInfoResponse {
+        ..Default::default()
+    };
+
+    let resp_bytes = response.encode_to_vec();
+
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 628, 629],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8909),
+        ..Default::default()
+    };
+
+    let (route, code) = PacketCodeType::EquipInfo.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_lock.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipLockRequest, EquipLockResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipLockRequest) -> GameResponse {
+    info!("Handling EquipLockRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipLockResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipLock.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_making.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipMakingRequest, EquipMakingResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipMakingRequest) -> GameResponse {
+    info!("Handling EquipMakingRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipMakingResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipMaking.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_mark_delete.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipMarkDeleteRequest, EquipMarkDeleteResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipMarkDeleteRequest) -> GameResponse {
+    info!("Handling EquipMarkDeleteRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipMarkDeleteResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipMarkDelete.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_mark_set.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipMarkSetRequest, EquipMarkSetResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipMarkSetRequest) -> GameResponse {
+    info!("Handling EquipMarkSetRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipMarkSetResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipMarkSet.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_option_re_roll.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipOptionReRollRequest, EquipOptionReRollResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipOptionReRollRequest) -> GameResponse {
+    info!("Handling EquipOptionReRollRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipOptionReRollResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipOptionReRoll.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}

gameserver/src/logic/game/equip_option_re_roll_confirm.rs

@@ -0,0 +1,43 @@
+use bd2::prost::Message;
+use bd2::proto::proto_net::{EquipOptionReRollConfirmRequest, EquipOptionReRollConfirmResponse, Notify };
+use common::packet_code::PacketCodeType;
+use crypto::network::GameResponse;
+use sqlx::SqlitePool;
+use tracing::info;
+
+pub async fn handle(_pool: &SqlitePool, _uid: i64, req: EquipOptionReRollConfirmRequest) -> GameResponse {
+    info!("Handling EquipOptionReRollConfirmRequest: {:?}", req);
+    
+    // TODO: Fetch data from database
+    // Example:
+    // let data = get_something(pool, uid).await.unwrap_or_default();
+    
+    // TODO: Transform to proto
+    // Example:
+    // let proto_data = data.into_iter()
+    //     .map(|item| mapper::to_proto(item, pool).await)
+    //     .collect();
+    
+    let response = EquipOptionReRollConfirmResponse {
+        // TODO: Fill in response fields
+        ..Default::default()
+    };
+    
+    let resp_bytes = response.encode_to_vec();
+    
+    let notify = Notify {
+        achievement_update_info: vec![],
+        mission_update_info: vec![],
+        event_mission_update_info: vec![],
+        active_login_event: vec![1, 2, 625, 626, 627],
+        active_contents_info: vec![],
+        ll_type: Some("".to_string()),
+        is_purchasing_disabled: Some(false),
+        maintenance_start_date: Some(1688646600000),
+        notice_last_seq: Some(8818),
+        ..Default::default()
+    };
+    
+    let (route, code) = PacketCodeType::EquipOptionReRollConfirm.info();
+    GameResponse::success(route, &resp_bytes, code).with_notify(&notify)
+}