From 520bc2dc3b2ac58101cad1f37a42af73a0d488c8 Mon Sep 17 00:00:00 2001 From: xeon Date: Fri, 14 Mar 2025 23:28:27 +0300 Subject: [PATCH] Implement Beginner Procedure --- Cargo.lock | 1 + crates/game-server/src/logic/avatar_util.rs | 7 - crates/game-server/src/logic/mod.rs | 1 + crates/game-server/src/logic/player/mod.rs | 56 +- .../src/logic/player/player_util.rs | 7 +- crates/game-server/src/logic/scene/mod.rs | 22 + .../game-server/src/session/message/player.rs | 41 +- .../game-server/src/session/message/scene.rs | 120 +++- .../game-server/src/session/message/system.rs | 12 + .../src/session/message/workbench.rs | 7 + crates/game-server/src/session/mod.rs | 27 +- .../entity/src/player_basic_info.rs | 1 + crates/trigger-fileconfig/fbs/tables.fbs | 13 + .../gen_flatbuffers/tables_generated.rs | 279 ++++++++++ crates/trigger-fileconfig/src/lib.rs | 1 + crates/trigger-logic/Cargo.toml | 2 + crates/trigger-logic/src/lib.rs | 1 + crates/trigger-logic/src/scene.rs | 6 + crates/trigger-logic/src/template_ext.rs | 42 ++ crates/trigger-protobuf/out/_.rs | 156 ++++++ crates/trigger-protobuf/out/protocol_map.rs | 520 ++++++++++++++++++ crates/trigger-protocol/src/lib.rs | 94 ++++ 22 files changed, 1392 insertions(+), 24 deletions(-) create mode 100644 crates/game-server/src/logic/scene/mod.rs create mode 100644 crates/trigger-logic/src/template_ext.rs diff --git a/Cargo.lock b/Cargo.lock index 7c5d40e..c1d30fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3750,6 +3750,7 @@ version = "0.0.1" dependencies = [ "num_enum", "prost", + "trigger-fileconfig", ] [[package]] diff --git a/crates/game-server/src/logic/avatar_util.rs b/crates/game-server/src/logic/avatar_util.rs index df59a77..fdae2bd 100644 --- a/crates/game-server/src/logic/avatar_util.rs +++ b/crates/game-server/src/logic/avatar_util.rs @@ -1,10 +1,3 @@ -pub const MALE_AVATAR_ID: u32 = 2011; -pub const FEMALE_AVATAR_ID: u32 = 2021; - -pub fn is_player_avatar(id: u32) -> bool { - id == MALE_AVATAR_ID || id == FEMALE_AVATAR_ID -} - pub fn is_valid_talent_switch(v: &[bool]) -> bool { v.len() == 6 && v[0..3] diff --git a/crates/game-server/src/logic/mod.rs b/crates/game-server/src/logic/mod.rs index bd37e43..e9efa41 100644 --- a/crates/game-server/src/logic/mod.rs +++ b/crates/game-server/src/logic/mod.rs @@ -4,6 +4,7 @@ pub mod dungeon_util; pub mod equip_util; pub mod gm_util; mod player; +pub mod scene; pub mod scene_util; pub use player::NapPlayer; diff --git a/crates/game-server/src/logic/player/mod.rs b/crates/game-server/src/logic/player/mod.rs index 070145e..3e49d17 100644 --- a/crates/game-server/src/logic/player/mod.rs +++ b/crates/game-server/src/logic/player/mod.rs @@ -8,7 +8,7 @@ use role::RoleModel; use scene::SceneModel; use trigger_database::{entity::*, prelude::*, DatabaseConnection}; use trigger_fileconfig::NapFileCfg; -use trigger_logic::scene::ESceneType; +use trigger_logic::{scene::ESceneType, template_ext::TemplateExt}; use trigger_protocol::PlayerInfo; use trigger_sv::message::GameStateData; use yorozuya::YorozuyaModel; @@ -62,11 +62,8 @@ impl NapPlayer { player_uid, }; - let Some((player_basic_info, is_new_player)) = - player_util::load_player_basic_info(database, player_uid, create_if_not_exists).await - else { - return None; - }; + let (player_basic_info, is_new_player) = + player_util::load_player_basic_info(database, player_uid, create_if_not_exists).await?; let role_model = RoleModel::init(context.clone()).await; let item_model = ItemModel::init(context.clone()).await; @@ -95,6 +92,28 @@ impl NapPlayer { }) } + pub fn beginner_procedure_id(&self) -> Option { + (self.player_basic_info.beginner_procedure_id != -1) + .then_some(self.player_basic_info.beginner_procedure_id) + } + + pub async fn advance_beginner_procedure(&mut self, id: i32) { + let active_model = player_basic_info::ActiveModel { + beginner_procedure_id: Set(self + .context + .filecfg + .is_last_procedure(id) + .then_some(-1) + .unwrap_or(id)), + ..self.player_basic_info.clone().into() + }; + + self.player_basic_info = active_model + .update(self.context.database) + .await + .expect("player_basic_info::update failed"); + } + pub fn build_state_reentrant_data(&self, scene: &scene_info::Model) -> Option { match ESceneType::try_from(scene.scene_type).unwrap() { ESceneType::Hall => Some(GameStateData::Hall { @@ -106,6 +125,31 @@ impl NapPlayer { } } + pub async fn select_role(&mut self, avatar_id: u32) { + let mut active_model: player_basic_info::ActiveModel = + self.player_basic_info.clone().into(); + + active_model.set( + player_basic_info::Column::AvatarId, + (avatar_id as i32).into(), + ); + + active_model.set( + player_basic_info::Column::PlayerAvatarId, + (avatar_id as i32).into(), + ); + + active_model.set( + player_basic_info::Column::ControlAvatarId, + (avatar_id as i32).into(), + ); + + self.player_basic_info = active_model + .update(self.context.database) + .await + .expect("player_basic_info::update failed"); + } + pub async fn set_control_avatars(&mut self, player_avatar_id: u32, control_avatar_id: u32) { let mut active_model: player_basic_info::ActiveModel = self.player_basic_info.clone().into(); diff --git a/crates/game-server/src/logic/player/player_util.rs b/crates/game-server/src/logic/player/player_util.rs index 13e85ab..f7179f0 100644 --- a/crates/game-server/src/logic/player/player_util.rs +++ b/crates/game-server/src/logic/player/player_util.rs @@ -32,9 +32,10 @@ fn create_default_player_basic_info(player_uid: i32) -> player_basic_info::Activ nick_name: String::from("ReversedRooms"), level: 60, exp: 0, - avatar_id: 2021, - player_avatar_id: 2021, - control_avatar_id: 1361, + avatar_id: 0, + player_avatar_id: 0, + control_avatar_id: 0, + beginner_procedure_id: 0, } .into() } diff --git a/crates/game-server/src/logic/scene/mod.rs b/crates/game-server/src/logic/scene/mod.rs new file mode 100644 index 0000000..1e6188f --- /dev/null +++ b/crates/game-server/src/logic/scene/mod.rs @@ -0,0 +1,22 @@ +use trigger_logic::scene::ESceneType; + +#[derive(Debug)] +pub enum ServerlessStateData { + FreshScene { procedure_id: i32 }, +} + +impl ServerlessStateData { + pub fn protocol_scene_data(&self) -> trigger_protocol::SceneData { + use trigger_protocol::*; + + match self { + Self::FreshScene { procedure_id } => SceneData { + scene_type: ESceneType::Fresh.into(), + fresh_scene_info: Some(FreshSceneInfo { + last_procedure_id: *procedure_id as u32, + }), + ..Default::default() + }, + } + } +} diff --git a/crates/game-server/src/session/message/player.rs b/crates/game-server/src/session/message/player.rs index 95d07bd..2fd503c 100644 --- a/crates/game-server/src/session/message/player.rs +++ b/crates/game-server/src/session/message/player.rs @@ -4,10 +4,9 @@ use trigger_codegen::handlers; #[handlers] mod player_module { use tracing::debug; + use trigger_logic::template_ext::TemplateExt; use trigger_sv::{net::ServerType, time_util}; - use crate::logic::avatar_util; - pub async fn on_get_player_info( context: &mut MessageContext<'_, '_>, _request: GetPlayerInfoCsReq, @@ -39,6 +38,34 @@ mod player_module { } } + pub async fn on_select_role( + context: &mut MessageContext<'_, '_>, + request: SelectRoleCsReq, + ) -> SelectRoleScRsp { + if let Some(procedure_id) = context.player.beginner_procedure_id() { + if context + .state + .filecfg + .procedure_allows_select_role(procedure_id + 1) + && context + .state + .filecfg + .is_player_avatar(request.avatar_id as i32) + { + context.player.select_role(request.avatar_id).await; + + context.add_notify(PlayerSyncScNotify { + player_info: Some(context.player.get_protocol_player_info()), + ..Default::default() + }); + + return SelectRoleScRsp { retcode: 0 }; + } + } + + SelectRoleScRsp { retcode: 1 } + } + pub async fn on_get_authkey( context: &mut MessageContext<'_, '_>, request: GetAuthkeyCsReq, @@ -69,8 +96,14 @@ mod player_module { context: &mut MessageContext<'_, '_>, request: SwitchRoleCsReq, ) -> SwitchRoleScRsp { - if avatar_util::is_player_avatar(request.player_avatar_id) - && (avatar_util::is_player_avatar(request.control_avatar_id) + if context + .state + .filecfg + .is_player_avatar(request.player_avatar_id as i32) + && (context + .state + .filecfg + .is_player_avatar(request.control_avatar_id as i32) || context .player .role_model diff --git a/crates/game-server/src/session/message/scene.rs b/crates/game-server/src/session/message/scene.rs index 166f7d3..26c7d1c 100644 --- a/crates/game-server/src/session/message/scene.rs +++ b/crates/game-server/src/session/message/scene.rs @@ -5,11 +5,28 @@ use trigger_codegen::handlers; mod scene_module { use tracing::debug; use trigger_logic::scene::{ELocalPlayType, ESceneType}; - use trigger_sv::message::GameStateData; + use trigger_sv::{ + message::{AvailableServerProtocolMessage, GameStateData}, + net::ServerType, + }; - use crate::logic::{dungeon_util, scene_util}; + use crate::logic::{dungeon_util, scene::ServerlessStateData, scene_util}; pub async fn on_enter_world(context: &mut MessageContext<'_, '_>, _request: EnterWorldCsReq) { + if let Some(procedure_id) = context.player.beginner_procedure_id() { + debug!("entering beginner procedure, id: {procedure_id}"); + + context + .session + .load_serverless_state( + ServerlessStateData::FreshScene { procedure_id }, + context.request_id, + EnterWorldScRsp::default(), + ) + .await; + return; + } + let scene_model = &mut context.player.scene_model; let scene_to_enter = match scene_model.get_current_scene().await { @@ -24,7 +41,6 @@ mod scene_module { }; let scene_to_enter = if scene_to_enter.is_none() { - // TODO: first scene to be created should be the 'Fresh' scene (beginner procedure) debug!( "player with uid {} has no scene to enter, default hall scene will be created", context.session.player_uid @@ -149,6 +165,104 @@ mod scene_module { .await; } + pub async fn on_advance_beginner_procedure( + context: &mut MessageContext<'_, '_>, + request: AdvanceBeginnerProcedureCsReq, + ) { + let rsp = if let Some(procedure_id) = context.player.beginner_procedure_id() { + if request.procedure_id == procedure_id + 1 { + context + .player + .advance_beginner_procedure(request.procedure_id) + .await; + + let rsp = AdvanceBeginnerProcedureScRsp { + retcode: 0, + next_procedure_id: request.procedure_id, + }; + + if context.player.beginner_procedure_id().is_none() { + // Beginner procedure finished, enter the hall scene now + let scene_model = &mut context.player.scene_model; + let scene = scene_model.create_scene_info(ESceneType::Hall).await; + scene_model.set_default_scene(&scene).await; + + context + .session + .change_game_state( + context.request_id, + rsp, + context.player.build_state_reentrant_data(&scene).unwrap(), + &scene, + context.player, + false, + ) + .await; + + None + } else { + Some(rsp) + } + } else { + debug!( + "invalid procedure transition (from: {}, to: {})", + procedure_id, request.procedure_id + ); + + Some(AdvanceBeginnerProcedureScRsp { + retcode: 1, + ..Default::default() + }) + } + } else { + Some(AdvanceBeginnerProcedureScRsp { + retcode: 1, + ..Default::default() + }) + }; + + if let Some(rsp) = rsp { + context + .session + .network_mgr + .send_to( + ServerType::GateServer, + 0, + AvailableServerProtocolMessage { + session_id: context.session.id, + ack_request_id: context.request_id, + notifies: Vec::new(), + response: Some(rsp.into()), + }, + ) + .await; + } + } + + pub async fn on_beginnerbattle_begin( + _context: &mut MessageContext<'_, '_>, + request: BeginnerbattleBeginCsReq, + ) -> BeginnerbattleBeginScRsp { + BeginnerbattleBeginScRsp { + retcode: 0, + battle_uid: request.battle_id as i64, + } + } + + pub async fn on_beginnerbattle_rebegin( + _context: &mut MessageContext<'_, '_>, + _request: BeginnerbattleRebeginCsReq, + ) -> BeginnerbattleRebeginScRsp { + BeginnerbattleRebeginScRsp { retcode: 0 } + } + + pub async fn on_beginnerbattle_end( + _context: &mut MessageContext<'_, '_>, + _request: BeginnerbattleEndCsReq, + ) -> BeginnerbattleEndScRsp { + BeginnerbattleEndScRsp { retcode: 0 } + } + pub async fn on_active_hollow_check_point( _context: &mut MessageContext<'_, '_>, request: ActiveHollowCheckPointCsReq, diff --git a/crates/game-server/src/session/message/system.rs b/crates/game-server/src/session/message/system.rs index 4edd274..4e53cf2 100644 --- a/crates/game-server/src/session/message/system.rs +++ b/crates/game-server/src/session/message/system.rs @@ -185,6 +185,18 @@ mod client_systems_module { } } + pub async fn on_end_newbie( + _context: &mut MessageContext<'_, '_>, + request: EndNewbieCsReq, + ) -> EndNewbieScRsp { + debug!("EndNewbie({})", request.group_id); + + EndNewbieScRsp { + retcode: 0, + group_id: 0, + } + } + pub async fn on_get_trashbin_hermit_data( _context: &mut MessageContext<'_, '_>, _request: GetTrashbinHermitDataCsReq, diff --git a/crates/game-server/src/session/message/workbench.rs b/crates/game-server/src/session/message/workbench.rs index 3fd8bf5..b91930b 100644 --- a/crates/game-server/src/session/message/workbench.rs +++ b/crates/game-server/src/session/message/workbench.rs @@ -35,4 +35,11 @@ mod workbench_module { abyss_reward_data: Some(AbyssRewardData::default()), } } + + pub async fn on_unlock_clue_item( + _context: &mut MessageContext<'_, '_>, + _request: UnlockClueItemCsReq, + ) -> UnlockClueItemScRsp { + UnlockClueItemScRsp { retcode: 0 } + } } diff --git a/crates/game-server/src/session/mod.rs b/crates/game-server/src/session/mod.rs index d1bdc59..e016575 100644 --- a/crates/game-server/src/session/mod.rs +++ b/crates/game-server/src/session/mod.rs @@ -15,7 +15,7 @@ use trigger_sv::{ net::{ServerNetworkManager, ServerType}, }; -use crate::logic::{scene_util, NapPlayer}; +use crate::logic::{scene::ServerlessStateData, scene_util, NapPlayer}; pub mod message; @@ -50,6 +50,31 @@ impl GameSession { } } + pub async fn load_serverless_state( + &self, + state_data: ServerlessStateData, + ack_request_id: u32, + response: impl Into, + ) { + let enter_scene_notify = trigger_protocol::EnterSceneScNotify { + scene: Some(state_data.protocol_scene_data()), + dungeon: None, + }; + + self.network_mgr + .send_to( + ServerType::GateServer, + 0, + AvailableServerProtocolMessage { + session_id: self.id, + ack_request_id, + notifies: vec![enter_scene_notify.into()], + response: Some(response.into()), + }, + ) + .await; + } + pub async fn change_game_state( &self, ack_request_id: u32, diff --git a/crates/trigger-database/entity/src/player_basic_info.rs b/crates/trigger-database/entity/src/player_basic_info.rs index 5537285..84cf282 100644 --- a/crates/trigger-database/entity/src/player_basic_info.rs +++ b/crates/trigger-database/entity/src/player_basic_info.rs @@ -11,6 +11,7 @@ pub struct Model { pub avatar_id: i32, pub player_avatar_id: i32, pub control_avatar_id: i32, + pub beginner_procedure_id: i32, } #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)] diff --git a/crates/trigger-fileconfig/fbs/tables.fbs b/crates/trigger-fileconfig/fbs/tables.fbs index 7d667b6..23af39c 100644 --- a/crates/trigger-fileconfig/fbs/tables.fbs +++ b/crates/trigger-fileconfig/fbs/tables.fbs @@ -380,6 +380,15 @@ table ConditionConfigTemplate { type: int; } +table ProcedureConfigTemplate { + procedure_id: int; + procedure_type: int; + content_id: string; + jump_tos: [int]; + procedure_banks: [string]; + procedure_event: string; +} + table AvatarBaseTemplateTb { data: [AvatarBaseTemplate]; } @@ -451,3 +460,7 @@ table TeleportConfigTemplateTb { table ConditionConfigTemplateTb { data: [ConditionConfigTemplate]; } + +table ProcedureConfigTemplateTb { + data: [ProcedureConfigTemplate]; +} diff --git a/crates/trigger-fileconfig/gen_flatbuffers/tables_generated.rs b/crates/trigger-fileconfig/gen_flatbuffers/tables_generated.rs index 43c5f57..f81514b 100644 --- a/crates/trigger-fileconfig/gen_flatbuffers/tables_generated.rs +++ b/crates/trigger-fileconfig/gen_flatbuffers/tables_generated.rs @@ -7111,6 +7111,188 @@ impl core::fmt::Debug for ConditionConfigTemplate<'_> { ds.finish() } } +pub enum ProcedureConfigTemplateOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ProcedureConfigTemplate<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ProcedureConfigTemplate<'a> { + type Inner = ProcedureConfigTemplate<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ProcedureConfigTemplate<'a> { + pub const VT_PROCEDURE_ID: flatbuffers::VOffsetT = 4; + pub const VT_PROCEDURE_TYPE: flatbuffers::VOffsetT = 6; + pub const VT_CONTENT_ID: flatbuffers::VOffsetT = 8; + pub const VT_JUMP_TOS: flatbuffers::VOffsetT = 10; + pub const VT_PROCEDURE_BANKS: flatbuffers::VOffsetT = 12; + pub const VT_PROCEDURE_EVENT: flatbuffers::VOffsetT = 14; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ProcedureConfigTemplate { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ProcedureConfigTemplateArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ProcedureConfigTemplateBuilder::new(_fbb); + if let Some(x) = args.procedure_event { builder.add_procedure_event(x); } + if let Some(x) = args.procedure_banks { builder.add_procedure_banks(x); } + if let Some(x) = args.jump_tos { builder.add_jump_tos(x); } + if let Some(x) = args.content_id { builder.add_content_id(x); } + builder.add_procedure_type(args.procedure_type); + builder.add_procedure_id(args.procedure_id); + builder.finish() + } + + + #[inline] + pub fn procedure_id(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ProcedureConfigTemplate::VT_PROCEDURE_ID, Some(0)).unwrap()} + } + #[inline] + pub fn procedure_type(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ProcedureConfigTemplate::VT_PROCEDURE_TYPE, Some(0)).unwrap()} + } + #[inline] + pub fn content_id(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ProcedureConfigTemplate::VT_CONTENT_ID, None)} + } + #[inline] + pub fn jump_tos(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(ProcedureConfigTemplate::VT_JUMP_TOS, None)} + } + #[inline] + pub fn procedure_banks(&self) -> Option>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(ProcedureConfigTemplate::VT_PROCEDURE_BANKS, None)} + } + #[inline] + pub fn procedure_event(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ProcedureConfigTemplate::VT_PROCEDURE_EVENT, None)} + } +} + +impl flatbuffers::Verifiable for ProcedureConfigTemplate<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("procedure_id", Self::VT_PROCEDURE_ID, false)? + .visit_field::("procedure_type", Self::VT_PROCEDURE_TYPE, false)? + .visit_field::>("content_id", Self::VT_CONTENT_ID, false)? + .visit_field::>>("jump_tos", Self::VT_JUMP_TOS, false)? + .visit_field::>>>("procedure_banks", Self::VT_PROCEDURE_BANKS, false)? + .visit_field::>("procedure_event", Self::VT_PROCEDURE_EVENT, false)? + .finish(); + Ok(()) + } +} +pub struct ProcedureConfigTemplateArgs<'a> { + pub procedure_id: i32, + pub procedure_type: i32, + pub content_id: Option>, + pub jump_tos: Option>>, + pub procedure_banks: Option>>>, + pub procedure_event: Option>, +} +impl<'a> Default for ProcedureConfigTemplateArgs<'a> { + #[inline] + fn default() -> Self { + ProcedureConfigTemplateArgs { + procedure_id: 0, + procedure_type: 0, + content_id: None, + jump_tos: None, + procedure_banks: None, + procedure_event: None, + } + } +} + +pub struct ProcedureConfigTemplateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ProcedureConfigTemplateBuilder<'a, 'b, A> { + #[inline] + pub fn add_procedure_id(&mut self, procedure_id: i32) { + self.fbb_.push_slot::(ProcedureConfigTemplate::VT_PROCEDURE_ID, procedure_id, 0); + } + #[inline] + pub fn add_procedure_type(&mut self, procedure_type: i32) { + self.fbb_.push_slot::(ProcedureConfigTemplate::VT_PROCEDURE_TYPE, procedure_type, 0); + } + #[inline] + pub fn add_content_id(&mut self, content_id: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ProcedureConfigTemplate::VT_CONTENT_ID, content_id); + } + #[inline] + pub fn add_jump_tos(&mut self, jump_tos: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ProcedureConfigTemplate::VT_JUMP_TOS, jump_tos); + } + #[inline] + pub fn add_procedure_banks(&mut self, procedure_banks: flatbuffers::WIPOffset>>) { + self.fbb_.push_slot_always::>(ProcedureConfigTemplate::VT_PROCEDURE_BANKS, procedure_banks); + } + #[inline] + pub fn add_procedure_event(&mut self, procedure_event: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ProcedureConfigTemplate::VT_PROCEDURE_EVENT, procedure_event); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ProcedureConfigTemplateBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + ProcedureConfigTemplateBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ProcedureConfigTemplate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ProcedureConfigTemplate"); + ds.field("procedure_id", &self.procedure_id()); + ds.field("procedure_type", &self.procedure_type()); + ds.field("content_id", &self.content_id()); + ds.field("jump_tos", &self.jump_tos()); + ds.field("procedure_banks", &self.procedure_banks()); + ds.field("procedure_event", &self.procedure_event()); + ds.finish() + } +} pub enum AvatarBaseTemplateTbOffset {} #[derive(Copy, Clone, PartialEq)] @@ -8857,3 +9039,100 @@ impl core::fmt::Debug for ConditionConfigTemplateTb<'_> { ds.finish() } } +pub enum ProcedureConfigTemplateTbOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ProcedureConfigTemplateTb<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ProcedureConfigTemplateTb<'a> { + type Inner = ProcedureConfigTemplateTb<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ProcedureConfigTemplateTb<'a> { + pub const VT_DATA: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ProcedureConfigTemplateTb { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ProcedureConfigTemplateTbArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ProcedureConfigTemplateTbBuilder::new(_fbb); + if let Some(x) = args.data { builder.add_data(x); } + builder.finish() + } + + + #[inline] + pub fn data(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(ProcedureConfigTemplateTb::VT_DATA, None)} + } +} + +impl flatbuffers::Verifiable for ProcedureConfigTemplateTb<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("data", Self::VT_DATA, false)? + .finish(); + Ok(()) + } +} +pub struct ProcedureConfigTemplateTbArgs<'a> { + pub data: Option>>>>, +} +impl<'a> Default for ProcedureConfigTemplateTbArgs<'a> { + #[inline] + fn default() -> Self { + ProcedureConfigTemplateTbArgs { + data: None, + } + } +} + +pub struct ProcedureConfigTemplateTbBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ProcedureConfigTemplateTbBuilder<'a, 'b, A> { + #[inline] + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(ProcedureConfigTemplateTb::VT_DATA, data); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ProcedureConfigTemplateTbBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + ProcedureConfigTemplateTbBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ProcedureConfigTemplateTb<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ProcedureConfigTemplateTb"); + ds.field("data", &self.data()); + ds.finish() + } +} diff --git a/crates/trigger-fileconfig/src/lib.rs b/crates/trigger-fileconfig/src/lib.rs index 50be6ac..042b276 100644 --- a/crates/trigger-fileconfig/src/lib.rs +++ b/crates/trigger-fileconfig/src/lib.rs @@ -45,6 +45,7 @@ file_cfg! { WeaponTemplateTb; EquipmentTemplateTb; EquipmentSuitTemplateTb; + ProcedureConfigTemplateTb; UnlockConfigTemplateTb; PostGirlConfigTemplateTb; ArchiveFileQuestTemplateTb; diff --git a/crates/trigger-logic/Cargo.toml b/crates/trigger-logic/Cargo.toml index 051224e..ddcabe1 100644 --- a/crates/trigger-logic/Cargo.toml +++ b/crates/trigger-logic/Cargo.toml @@ -6,3 +6,5 @@ version.workspace = true [dependencies] num_enum.workspace = true prost.workspace = true + +trigger-fileconfig.workspace = true diff --git a/crates/trigger-logic/src/lib.rs b/crates/trigger-logic/src/lib.rs index ce07c15..982a71e 100644 --- a/crates/trigger-logic/src/lib.rs +++ b/crates/trigger-logic/src/lib.rs @@ -3,3 +3,4 @@ pub mod item; pub mod quest; pub mod scene; pub mod skill; +pub mod template_ext; diff --git a/crates/trigger-logic/src/scene.rs b/crates/trigger-logic/src/scene.rs index 51d7312..596b8fb 100644 --- a/crates/trigger-logic/src/scene.rs +++ b/crates/trigger-logic/src/scene.rs @@ -107,3 +107,9 @@ impl From> for Vector3f { } } } + +impl From for u32 { + fn from(value: ESceneType) -> Self { + i16::from(value) as u32 + } +} diff --git a/crates/trigger-logic/src/template_ext.rs b/crates/trigger-logic/src/template_ext.rs new file mode 100644 index 0000000..98568bb --- /dev/null +++ b/crates/trigger-logic/src/template_ext.rs @@ -0,0 +1,42 @@ +use trigger_fileconfig::NapFileCfg; + +pub trait TemplateExt { + fn is_player_avatar(&self, avatar_id: i32) -> bool; + fn procedure_allows_select_role(&self, procedure_id: i32) -> bool; + fn is_last_procedure(&self, procedure_id: i32) -> bool; +} + +impl TemplateExt for NapFileCfg { + fn is_player_avatar(&self, avatar_id: i32) -> bool { + self.avatar_base_template_tb() + .data() + .unwrap() + .iter() + .find_map(|tmpl| (tmpl.id() == avatar_id && tmpl.camp() == 0).then_some(true)) + .unwrap_or(false) + } + + fn procedure_allows_select_role(&self, procedure_id: i32) -> bool { + self.procedure_config_template_tb() + .data() + .unwrap() + .iter() + .find_map(|tmpl| { + (tmpl.procedure_id() == procedure_id && tmpl.procedure_type() == 4).then_some(true) + }) + .unwrap_or(false) + } + + fn is_last_procedure(&self, procedure_id: i32) -> bool { + // faggots nuked JumpTos from client data btw! + + self.procedure_config_template_tb() + .data() + .unwrap() + .iter() + .max_by_key(|tmpl| tmpl.procedure_id()) + .unwrap() + .procedure_id() + == procedure_id + } +} diff --git a/crates/trigger-protobuf/out/_.rs b/crates/trigger-protobuf/out/_.rs index 1b57c68..a163dc7 100644 --- a/crates/trigger-protobuf/out/_.rs +++ b/crates/trigger-protobuf/out/_.rs @@ -10,6 +10,18 @@ pub struct GetRewardBuffDataScRsp { pub retcode: i32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(7670)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BeginnerbattleBeginScRsp { + #[xor(8649)] + #[prost(int64, tag = "14")] + pub battle_uid: i64, + #[xor(10326)] + #[prost(int32, tag = "3")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PlayerInfo { @@ -85,6 +97,15 @@ pub struct Equip { pub exp: u32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(3935)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct SelectRoleCsReq { + #[xor(9750)] + #[prost(uint32, tag = "7")] + pub avatar_id: u32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(1850)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -362,6 +383,15 @@ pub struct DressEquipmentCsReq { pub equip_uid: u32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(6113)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BeginnerbattleBeginCsReq { + #[xor(12379)] + #[prost(int32, tag = "15")] + pub battle_id: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(6803)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -398,6 +428,27 @@ pub struct GetActivityDataScRsp { pub retcode: i32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(1970)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BeginnerbattleEndCsReq { + #[xor(322)] + #[prost(int64, tag = "4")] + pub battle_uid: i64, + #[xor(1154)] + #[prost(int32, tag = "11")] + pub battle_id: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(5251)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnlockClueItemScRsp { + #[xor(379)] + #[prost(int32, tag = "7")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(8370)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -509,6 +560,15 @@ pub struct TipsSync { pub fairy_groups: ::std::collections::HashMap, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(842)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BeginnerbattleEndScRsp { + #[xor(12999)] + #[prost(int32, tag = "11")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Transform { @@ -549,6 +609,15 @@ pub struct EnterSectionCsReq { pub owner_type: i32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(9995)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BeginnerbattleRebeginScRsp { + #[xor(9333)] + #[prost(int32, tag = "7")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RallySceneInfo { @@ -660,6 +729,18 @@ pub struct AbyssGetDataScRsp { pub abyss_group_list: ::prost::alloc::vec::Vec, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(480)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BeginnerbattleRebeginCsReq { + #[xor(3447)] + #[prost(int64, tag = "9")] + pub battle_uid: i64, + #[xor(4358)] + #[prost(int32, tag = "15")] + pub battle_id: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct VhsGuestInfo { @@ -683,6 +764,18 @@ pub struct GetExplorationDataCsReq {} #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct GetResourceDataCsReq {} #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(3734)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AdvanceBeginnerProcedureCsReq { + #[xor(4241)] + #[prost(int32, tag = "5")] + pub params: i32, + #[xor(7267)] + #[prost(int32, tag = "7")] + pub procedure_id: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(4813)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -726,6 +819,14 @@ pub struct StartHollowQuestScRsp { } #[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct FreshSceneInfo { + #[xor(13677)] + #[prost(uint32, tag = "7")] + pub last_procedure_id: u32, +} +#[derive(trigger_protobuf_derive::CmdID)] +#[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct TipsInfo { #[prost(int32, repeated, tag = "12")] @@ -752,6 +853,9 @@ pub struct SavePlayerSystemSettingCsReq { #[xor(6028)] #[prost(uint32, tag = "10")] pub r#type: u32, + #[xor(8376)] + #[prost(uint32, tag = "14")] + pub params: u32, } #[derive(trigger_protobuf_derive::CmdID)] #[cmdid(2418)] @@ -1001,6 +1105,18 @@ pub struct WeaponDressCsReq { pub weapon_uid: u32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(8333)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct EndNewbieScRsp { + #[xor(7830)] + #[prost(uint32, tag = "9")] + pub group_id: u32, + #[xor(16016)] + #[prost(int32, tag = "2")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(8553)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -1029,6 +1145,14 @@ pub struct HollowInfo { pub hollow_quest_id: u32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(5937)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnlockClueItemCsReq { + #[prost(enumeration = "Lclkcaiolep", tag = "4")] + pub r#type: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(9350)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -1136,6 +1260,18 @@ pub struct ActiveHollowCheckPointCsReq { #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct GetServerTimestampCsReq {} #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(9745)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AdvanceBeginnerProcedureScRsp { + #[xor(9328)] + #[prost(int32, tag = "6")] + pub next_procedure_id: i32, + #[xor(5852)] + #[prost(int32, tag = "7")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(7723)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1476,6 +1612,15 @@ pub struct VhsFlowBuffInfo { pub buff_source: i32, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(4652)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct SelectRoleScRsp { + #[xor(417)] + #[prost(int32, tag = "7")] + pub retcode: i32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[cmdid(6289)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -1983,6 +2128,15 @@ pub struct VhsStoreData { pub is_need_refresh: bool, } #[derive(trigger_protobuf_derive::CmdID)] +#[cmdid(5983)] +#[derive(trigger_protobuf_derive::XorFields)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct EndNewbieCsReq { + #[xor(413)] + #[prost(uint32, tag = "11")] + pub group_id: u32, +} +#[derive(trigger_protobuf_derive::CmdID)] #[derive(trigger_protobuf_derive::XorFields)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct SystemSettings { @@ -2055,6 +2209,8 @@ pub struct MusicPlayerItem { pub struct SceneData { #[prost(message, optional, tag = "11")] pub hall_scene_info: ::core::option::Option, + #[prost(message, optional, tag = "12")] + pub fresh_scene_info: ::core::option::Option, #[xor(10113)] #[prost(uint32, tag = "6")] pub local_play_type: u32, diff --git a/crates/trigger-protobuf/out/protocol_map.rs b/crates/trigger-protobuf/out/protocol_map.rs index cd40281..5532243 100644 --- a/crates/trigger-protobuf/out/protocol_map.rs +++ b/crates/trigger-protobuf/out/protocol_map.rs @@ -11,6 +11,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleBeginScRsp::CMD_ID => { + let mut pb_message = BeginnerbattleBeginScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleBeginScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetBuddyDataCsReq::CMD_ID => { let mut pb_message = GetBuddyDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -27,6 +35,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + SelectRoleCsReq::CMD_ID => { + let mut pb_message = SelectRoleCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::SelectRoleCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } HollowDataRefreshCsReq::CMD_ID => { let mut pb_message = HollowDataRefreshCsReq::decode(pb)?; pb_message.xor_fields(); @@ -163,6 +179,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleBeginCsReq::CMD_ID => { + let mut pb_message = BeginnerbattleBeginCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleBeginCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetTipsDataScRsp::CMD_ID => { let mut pb_message = GetTipsDataScRsp::decode(pb)?; pb_message.xor_fields(); @@ -187,6 +211,22 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleEndCsReq::CMD_ID => { + let mut pb_message = BeginnerbattleEndCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleEndCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } + UnlockClueItemScRsp::CMD_ID => { + let mut pb_message = UnlockClueItemScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::UnlockClueItemScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } PerformTriggerCsReq::CMD_ID => { let mut pb_message = PerformTriggerCsReq::decode(pb)?; pb_message.xor_fields(); @@ -243,6 +283,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleEndScRsp::CMD_ID => { + let mut pb_message = BeginnerbattleEndScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleEndScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } PerformJumpCsReq::CMD_ID => { let mut pb_message = PerformJumpCsReq::decode(pb)?; pb_message.xor_fields(); @@ -259,6 +307,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleRebeginScRsp::CMD_ID => { + let mut pb_message = BeginnerbattleRebeginScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleRebeginScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetPlayerInfoCsReq::CMD_ID => { let mut pb_message = GetPlayerInfoCsReq::decode(pb)?; pb_message.xor_fields(); @@ -331,6 +387,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + BeginnerbattleRebeginCsReq::CMD_ID => { + let mut pb_message = BeginnerbattleRebeginCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::BeginnerbattleRebeginCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetExplorationDataCsReq::CMD_ID => { let mut pb_message = GetExplorationDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -347,6 +411,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + AdvanceBeginnerProcedureCsReq::CMD_ID => { + let mut pb_message = AdvanceBeginnerProcedureCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::AdvanceBeginnerProcedureCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } AbyssGetDataCsReq::CMD_ID => { let mut pb_message = AbyssGetDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -547,6 +619,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + EndNewbieScRsp::CMD_ID => { + let mut pb_message = EndNewbieScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::EndNewbieScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetRamenDataCsReq::CMD_ID => { let mut pb_message = GetRamenDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -563,6 +643,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + UnlockClueItemCsReq::CMD_ID => { + let mut pb_message = UnlockClueItemCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::UnlockClueItemCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetAvatarDataCsReq::CMD_ID => { let mut pb_message = GetAvatarDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -635,6 +723,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + AdvanceBeginnerProcedureScRsp::CMD_ID => { + let mut pb_message = AdvanceBeginnerProcedureScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::AdvanceBeginnerProcedureScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } PerformEndCsReq::CMD_ID => { let mut pb_message = PerformEndCsReq::decode(pb)?; pb_message.xor_fields(); @@ -771,6 +867,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + SelectRoleScRsp::CMD_ID => { + let mut pb_message = SelectRoleScRsp::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::SelectRoleScRsp::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } GetUnlockDataCsReq::CMD_ID => { let mut pb_message = GetUnlockDataCsReq::decode(pb)?; pb_message.xor_fields(); @@ -1051,6 +1155,14 @@ pub fn pb_to_common_protocol_unit( ); Ok(Some(common_protocol_message.into())) } + EndNewbieCsReq::CMD_ID => { + let mut pb_message = EndNewbieCsReq::decode(pb)?; + pb_message.xor_fields(); + let common_protocol_message = ::trigger_protocol::EndNewbieCsReq::from( + pb_message, + ); + Ok(Some(common_protocol_message.into())) + } LeaveCurSceneCsReq::CMD_ID => { let mut pb_message = LeaveCurSceneCsReq::decode(pb)?; pb_message.xor_fields(); @@ -1124,6 +1236,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetRewardBuffDataScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleBeginScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleBeginScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleBeginScRsp::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleBeginScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetBuddyDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetBuddyDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1140,6 +1260,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((BattleReportCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::SelectRoleCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::SelectRoleCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = SelectRoleCsReq::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((SelectRoleCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::HollowDataRefreshCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::HollowDataRefreshCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1282,6 +1410,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((DressEquipmentCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleBeginCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleBeginCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleBeginCsReq::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleBeginCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetTipsDataScRsp::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetTipsDataScRsp::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1306,6 +1442,22 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetActivityDataScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleEndCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleEndCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleEndCsReq::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleEndCsReq::CMD_ID, pb_message.encode_to_vec()))) + } + ::trigger_protocol::UnlockClueItemScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::UnlockClueItemScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = UnlockClueItemScRsp::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((UnlockClueItemScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::PerformTriggerCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::PerformTriggerCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1364,6 +1516,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetBuddyDataScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleEndScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleEndScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleEndScRsp::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleEndScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::PerformJumpCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::PerformJumpCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1380,6 +1540,16 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((EnterSectionCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleRebeginScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleRebeginScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleRebeginScRsp::from( + common_protocol_message, + ); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleRebeginScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetPlayerInfoCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetPlayerInfoCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1454,6 +1624,16 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((AbyssGetDataScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::BeginnerbattleRebeginCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::BeginnerbattleRebeginCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = BeginnerbattleRebeginCsReq::from( + common_protocol_message, + ); + pb_message.xor_fields(); + Ok(Some((BeginnerbattleRebeginCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetExplorationDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetExplorationDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1470,6 +1650,16 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetResourceDataCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::AdvanceBeginnerProcedureCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::AdvanceBeginnerProcedureCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = AdvanceBeginnerProcedureCsReq::from( + common_protocol_message, + ); + pb_message.xor_fields(); + Ok(Some((AdvanceBeginnerProcedureCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::AbyssGetDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::AbyssGetDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1690,6 +1880,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((WeaponDressCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::EndNewbieScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::EndNewbieScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = EndNewbieScRsp::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((EndNewbieScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetRamenDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetRamenDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1706,6 +1904,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((RunEventGraphScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::UnlockClueItemCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::UnlockClueItemCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = UnlockClueItemCsReq::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((UnlockClueItemCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetAvatarDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetAvatarDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1780,6 +1986,16 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetServerTimestampCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::AdvanceBeginnerProcedureScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::AdvanceBeginnerProcedureScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = AdvanceBeginnerProcedureScRsp::from( + common_protocol_message, + ); + pb_message.xor_fields(); + Ok(Some((AdvanceBeginnerProcedureScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::PerformEndCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::PerformEndCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -1927,6 +2143,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((GetPlayerInfoScRsp::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::SelectRoleScRsp::CMD_ID => { + let common_protocol_message = ::trigger_protocol::SelectRoleScRsp::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = SelectRoleScRsp::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((SelectRoleScRsp::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::GetUnlockDataCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::GetUnlockDataCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -2213,6 +2437,14 @@ pub fn common_protocol_unit_to_pb( pb_message.xor_fields(); Ok(Some((ClickHollowSystemCsReq::CMD_ID, pb_message.encode_to_vec()))) } + ::trigger_protocol::EndNewbieCsReq::CMD_ID => { + let common_protocol_message = ::trigger_protocol::EndNewbieCsReq::decode( + &mut ::std::io::Cursor::new(&unit.blob), + )?; + let mut pb_message = EndNewbieCsReq::from(common_protocol_message); + pb_message.xor_fields(); + Ok(Some((EndNewbieCsReq::CMD_ID, pb_message.encode_to_vec()))) + } ::trigger_protocol::LeaveCurSceneCsReq::CMD_ID => { let common_protocol_message = ::trigger_protocol::LeaveCurSceneCsReq::decode( &mut ::std::io::Cursor::new(&unit.blob), @@ -2295,6 +2527,26 @@ impl From<::trigger_protocol::GetRewardBuffDataScRsp> for GetRewardBuffDataScRsp } } #[allow(unused)] +impl From for ::trigger_protocol::BeginnerbattleBeginScRsp { + fn from(value: BeginnerbattleBeginScRsp) -> Self { + Self { + battle_uid: value.battle_uid.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleBeginScRsp> for BeginnerbattleBeginScRsp { + fn from(value: ::trigger_protocol::BeginnerbattleBeginScRsp) -> Self { + Self { + battle_uid: value.battle_uid.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::PlayerInfo { fn from(value: PlayerInfo) -> Self { Self { @@ -2409,6 +2661,24 @@ impl From<::trigger_protocol::Equip> for Equip { } } #[allow(unused)] +impl From for ::trigger_protocol::SelectRoleCsReq { + fn from(value: SelectRoleCsReq) -> Self { + Self { + avatar_id: value.avatar_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::SelectRoleCsReq> for SelectRoleCsReq { + fn from(value: ::trigger_protocol::SelectRoleCsReq) -> Self { + Self { + avatar_id: value.avatar_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::HollowDataRefreshCsReq { fn from(value: HollowDataRefreshCsReq) -> Self { Self { ..Default::default() } @@ -2961,6 +3231,24 @@ impl From<::trigger_protocol::DressEquipmentCsReq> for DressEquipmentCsReq { } } #[allow(unused)] +impl From for ::trigger_protocol::BeginnerbattleBeginCsReq { + fn from(value: BeginnerbattleBeginCsReq) -> Self { + Self { + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleBeginCsReq> for BeginnerbattleBeginCsReq { + fn from(value: ::trigger_protocol::BeginnerbattleBeginCsReq) -> Self { + Self { + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::GetTipsDataScRsp { fn from(value: GetTipsDataScRsp) -> Self { Self { @@ -3023,6 +3311,44 @@ impl From<::trigger_protocol::GetActivityDataScRsp> for GetActivityDataScRsp { } } #[allow(unused)] +impl From for ::trigger_protocol::BeginnerbattleEndCsReq { + fn from(value: BeginnerbattleEndCsReq) -> Self { + Self { + battle_uid: value.battle_uid.into(), + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleEndCsReq> for BeginnerbattleEndCsReq { + fn from(value: ::trigger_protocol::BeginnerbattleEndCsReq) -> Self { + Self { + battle_uid: value.battle_uid.into(), + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From for ::trigger_protocol::UnlockClueItemScRsp { + fn from(value: UnlockClueItemScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::UnlockClueItemScRsp> for UnlockClueItemScRsp { + fn from(value: ::trigger_protocol::UnlockClueItemScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::PerformTriggerCsReq { fn from(value: PerformTriggerCsReq) -> Self { Self { @@ -3211,6 +3537,24 @@ impl From<::trigger_protocol::GetBuddyDataScRsp> for GetBuddyDataScRsp { } } #[allow(unused)] +impl From for ::trigger_protocol::BeginnerbattleEndScRsp { + fn from(value: BeginnerbattleEndScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleEndScRsp> for BeginnerbattleEndScRsp { + fn from(value: ::trigger_protocol::BeginnerbattleEndScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::Transform { fn from(value: Transform) -> Self { Self { @@ -3273,6 +3617,26 @@ impl From<::trigger_protocol::EnterSectionCsReq> for EnterSectionCsReq { } } #[allow(unused)] +impl From +for ::trigger_protocol::BeginnerbattleRebeginScRsp { + fn from(value: BeginnerbattleRebeginScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleRebeginScRsp> +for BeginnerbattleRebeginScRsp { + fn from(value: ::trigger_protocol::BeginnerbattleRebeginScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::RallySceneInfo { fn from(value: RallySceneInfo) -> Self { Self { @@ -3467,6 +3831,28 @@ impl From<::trigger_protocol::AbyssGetDataScRsp> for AbyssGetDataScRsp { } } #[allow(unused)] +impl From +for ::trigger_protocol::BeginnerbattleRebeginCsReq { + fn from(value: BeginnerbattleRebeginCsReq) -> Self { + Self { + battle_uid: value.battle_uid.into(), + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::BeginnerbattleRebeginCsReq> +for BeginnerbattleRebeginCsReq { + fn from(value: ::trigger_protocol::BeginnerbattleRebeginCsReq) -> Self { + Self { + battle_uid: value.battle_uid.into(), + battle_id: value.battle_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::GetExplorationDataCsReq { fn from(value: GetExplorationDataCsReq) -> Self { Self { ..Default::default() } @@ -3491,6 +3877,28 @@ impl From<::trigger_protocol::GetResourceDataCsReq> for GetResourceDataCsReq { } } #[allow(unused)] +impl From +for ::trigger_protocol::AdvanceBeginnerProcedureCsReq { + fn from(value: AdvanceBeginnerProcedureCsReq) -> Self { + Self { + params: value.params.into(), + procedure_id: value.procedure_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::AdvanceBeginnerProcedureCsReq> +for AdvanceBeginnerProcedureCsReq { + fn from(value: ::trigger_protocol::AdvanceBeginnerProcedureCsReq) -> Self { + Self { + params: value.params.into(), + procedure_id: value.procedure_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::AbyssGetDataCsReq { fn from(value: AbyssGetDataCsReq) -> Self { Self { ..Default::default() } @@ -3561,6 +3969,24 @@ impl From<::trigger_protocol::StartHollowQuestScRsp> for StartHollowQuestScRsp { } } #[allow(unused)] +impl From for ::trigger_protocol::FreshSceneInfo { + fn from(value: FreshSceneInfo) -> Self { + Self { + last_procedure_id: value.last_procedure_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::FreshSceneInfo> for FreshSceneInfo { + fn from(value: ::trigger_protocol::FreshSceneInfo) -> Self { + Self { + last_procedure_id: value.last_procedure_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::TipsInfo { fn from(value: TipsInfo) -> Self { Self { @@ -3614,6 +4040,7 @@ for ::trigger_protocol::SavePlayerSystemSettingCsReq { fn from(value: SavePlayerSystemSettingCsReq) -> Self { Self { r#type: value.r#type.into(), + params: value.params.into(), ..Default::default() } } @@ -3624,6 +4051,7 @@ for SavePlayerSystemSettingCsReq { fn from(value: ::trigger_protocol::SavePlayerSystemSettingCsReq) -> Self { Self { r#type: value.r#type.into(), + params: value.params.into(), ..Default::default() } } @@ -4115,6 +4543,26 @@ impl From<::trigger_protocol::WeaponDressCsReq> for WeaponDressCsReq { } } #[allow(unused)] +impl From for ::trigger_protocol::EndNewbieScRsp { + fn from(value: EndNewbieScRsp) -> Self { + Self { + group_id: value.group_id.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::EndNewbieScRsp> for EndNewbieScRsp { + fn from(value: ::trigger_protocol::EndNewbieScRsp) -> Self { + Self { + group_id: value.group_id.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::GetRamenDataCsReq { fn from(value: GetRamenDataCsReq) -> Self { Self { ..Default::default() } @@ -4177,6 +4625,18 @@ impl From<::trigger_protocol::HollowInfo> for HollowInfo { } } #[allow(unused)] +impl From for ::trigger_protocol::UnlockClueItemCsReq { + fn from(value: UnlockClueItemCsReq) -> Self { + Self { ..Default::default() } + } +} +#[allow(unused)] +impl From<::trigger_protocol::UnlockClueItemCsReq> for UnlockClueItemCsReq { + fn from(value: ::trigger_protocol::UnlockClueItemCsReq) -> Self { + Self { ..Default::default() } + } +} +#[allow(unused)] impl From for ::trigger_protocol::GetAvatarDataCsReq { fn from(value: GetAvatarDataCsReq) -> Self { Self { ..Default::default() } @@ -4443,6 +4903,28 @@ impl From<::trigger_protocol::GetServerTimestampCsReq> for GetServerTimestampCsR } } #[allow(unused)] +impl From +for ::trigger_protocol::AdvanceBeginnerProcedureScRsp { + fn from(value: AdvanceBeginnerProcedureScRsp) -> Self { + Self { + next_procedure_id: value.next_procedure_id.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::AdvanceBeginnerProcedureScRsp> +for AdvanceBeginnerProcedureScRsp { + fn from(value: ::trigger_protocol::AdvanceBeginnerProcedureScRsp) -> Self { + Self { + next_procedure_id: value.next_procedure_id.into(), + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::PerformEndCsReq { fn from(value: PerformEndCsReq) -> Self { Self { @@ -4895,6 +5377,24 @@ impl From<::trigger_protocol::GetPlayerInfoScRsp> for GetPlayerInfoScRsp { } } #[allow(unused)] +impl From for ::trigger_protocol::SelectRoleScRsp { + fn from(value: SelectRoleScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::SelectRoleScRsp> for SelectRoleScRsp { + fn from(value: ::trigger_protocol::SelectRoleScRsp) -> Self { + Self { + retcode: value.retcode.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::GetUnlockDataCsReq { fn from(value: GetUnlockDataCsReq) -> Self { Self { ..Default::default() } @@ -5821,6 +6321,24 @@ impl From<::trigger_protocol::VhsStoreData> for VhsStoreData { } } #[allow(unused)] +impl From for ::trigger_protocol::EndNewbieCsReq { + fn from(value: EndNewbieCsReq) -> Self { + Self { + group_id: value.group_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] +impl From<::trigger_protocol::EndNewbieCsReq> for EndNewbieCsReq { + fn from(value: ::trigger_protocol::EndNewbieCsReq) -> Self { + Self { + group_id: value.group_id.into(), + ..Default::default() + } + } +} +#[allow(unused)] impl From for ::trigger_protocol::SystemSettings { fn from(value: SystemSettings) -> Self { Self { @@ -5969,6 +6487,7 @@ impl From for ::trigger_protocol::SceneData { fn from(value: SceneData) -> Self { Self { hall_scene_info: value.hall_scene_info.map(|v| v.into()), + fresh_scene_info: value.fresh_scene_info.map(|v| v.into()), local_play_type: value.local_play_type.into(), fight_scene_info: value.fight_scene_info.map(|v| v.into()), scene_type: value.scene_type.into(), @@ -5983,6 +6502,7 @@ impl From<::trigger_protocol::SceneData> for SceneData { fn from(value: ::trigger_protocol::SceneData) -> Self { Self { hall_scene_info: value.hall_scene_info.map(|v| v.into()), + fresh_scene_info: value.fresh_scene_info.map(|v| v.into()), local_play_type: value.local_play_type.into(), fight_scene_info: value.fight_scene_info.map(|v| v.into()), scene_type: value.scene_type.into(), diff --git a/crates/trigger-protocol/src/lib.rs b/crates/trigger-protocol/src/lib.rs index 428c7bb..b47963d 100644 --- a/crates/trigger-protocol/src/lib.rs +++ b/crates/trigger-protocol/src/lib.rs @@ -85,6 +85,18 @@ pub struct PlayerLogoutScRsp { pub retcode: i32, } +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(9)] +pub struct SelectRoleCsReq { + pub avatar_id: u32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(10)] +pub struct SelectRoleScRsp { + pub retcode: i32, +} + #[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] #[id(80)] pub struct SwitchRoleCsReq { @@ -269,6 +281,7 @@ pub struct SceneData { pub local_play_type: u32, pub hall_scene_info: Option, pub fight_scene_info: Option, + pub fresh_scene_info: Option, pub rally_scene_info: Option, } @@ -322,6 +335,11 @@ pub struct FightSceneInfo { pub level_reward_info: Option, } +#[derive(Default, Debug, Clone, Encodeable, Decodeable)] +pub struct FreshSceneInfo { + pub last_procedure_id: u32, +} + #[derive(Default, Debug, Clone, Encodeable, Decodeable)] pub struct PublicVariable { pub r#type: u32, @@ -560,6 +578,59 @@ pub struct ActiveHollowCheckPointScRsp { pub retcode: i32, } +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(477)] +pub struct AdvanceBeginnerProcedureCsReq { + pub procedure_id: i32, + pub params: i32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(478)] +pub struct AdvanceBeginnerProcedureScRsp { + pub retcode: i32, + pub next_procedure_id: i32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(479)] +pub struct BeginnerbattleBeginCsReq { + pub battle_id: i32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(480)] +pub struct BeginnerbattleBeginScRsp { + pub retcode: i32, + pub battle_uid: i64, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(481)] +pub struct BeginnerbattleRebeginCsReq { + pub battle_id: i32, + pub battle_uid: i64, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(482)] +pub struct BeginnerbattleRebeginScRsp { + pub retcode: i32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(483)] +pub struct BeginnerbattleEndCsReq { + pub battle_id: i32, + pub battle_uid: i64, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(484)] +pub struct BeginnerbattleEndScRsp { + pub retcode: i32, +} + // Quest #[derive(Default, Debug, Clone, Encodeable, Decodeable)] @@ -1272,6 +1343,19 @@ pub struct GetNewsStandDataScRsp { pub news_stand_data: Option, } +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(1323)] +pub struct EndNewbieCsReq { + pub group_id: u32, +} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(1324)] +pub struct EndNewbieScRsp { + pub retcode: i32, + pub group_id: u32, +} + #[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] #[id(1340)] pub struct GetTrashbinHermitDataCsReq {} @@ -1489,6 +1573,16 @@ pub struct GetWorkbenchDataScRsp { pub workbench_data: Option, } +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(2002)] +pub struct UnlockClueItemCsReq {} + +#[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] +#[id(2003)] +pub struct UnlockClueItemScRsp { + pub retcode: i32, +} + #[derive(Default, Debug, Clone, Encodeable, Decodeable, ClientCmdID)] #[id(2010)] pub struct GetPartnerDataCsReq {}