6592 lines
248 KiB
Rust
6592 lines
248 KiB
Rust
pub fn pb_to_common_protocol_unit(
|
|
pb_cmd_id: u16,
|
|
pb: &[u8],
|
|
) -> Result<Option<::trigger_protocol::util::ProtocolUnit>, crate::ProtobufDecodeError> {
|
|
match pb_cmd_id {
|
|
GetRewardBuffDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetRewardBuffDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRewardBuffDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetBuddyDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
BattleReportCsReq::CMD_ID => {
|
|
let mut pb_message = BattleReportCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::BattleReportCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::HollowDataRefreshCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
SavePosInMainCityCsReq::CMD_ID => {
|
|
let mut pb_message = SavePosInMainCityCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::SavePosInMainCityCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPartnerDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetPartnerDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPartnerDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EndBattleCsReq::CMD_ID => {
|
|
let mut pb_message = EndBattleCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EndBattleCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetBattleEventInfoCsReq::CMD_ID => {
|
|
let mut pb_message = GetBattleEventInfoCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetBattleEventInfoCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetQuestDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetQuestDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetQuestDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterSceneScNotify::CMD_ID => {
|
|
let mut pb_message = EnterSceneScNotify::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterSceneScNotify::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetHollowDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetHollowDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetHollowDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetCharacterQuestListCsReq::CMD_ID => {
|
|
let mut pb_message = GetCharacterQuestListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetCharacterQuestListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetTrashbinHermitDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetTrashbinHermitDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetTrashbinHermitDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPhotoWallDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetPhotoWallDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPhotoWallDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetCafeDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetCafeDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetCafeDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
VideoGetInfoScRsp::CMD_ID => {
|
|
let mut pb_message = VideoGetInfoScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::VideoGetInfoScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetShoppingMallInfoCsReq::CMD_ID => {
|
|
let mut pb_message = GetShoppingMallInfoCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetShoppingMallInfoCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
BeginArchiveBattleQuestCsReq::CMD_ID => {
|
|
let mut pb_message = BeginArchiveBattleQuestCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::BeginArchiveBattleQuestCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetBabelTowerDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetBabelTowerDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetBabelTowerDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
DressEquipmentCsReq::CMD_ID => {
|
|
let mut pb_message = DressEquipmentCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::DressEquipmentCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetTipsDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
RefreshSectionCsReq::CMD_ID => {
|
|
let mut pb_message = RefreshSectionCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::RefreshSectionCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetActivityDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetActivityDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetActivityDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::PerformTriggerCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPhotoWallDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetPhotoWallDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPhotoWallDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
InteractWithUnitCsReq::CMD_ID => {
|
|
let mut pb_message = InteractWithUnitCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::InteractWithUnitCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
WeaponUnDressCsReq::CMD_ID => {
|
|
let mut pb_message = WeaponUnDressCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::WeaponUnDressCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetArchiveDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetArchiveDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetArchiveDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPlayerTransactionCsReq::CMD_ID => {
|
|
let mut pb_message = GetPlayerTransactionCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerTransactionCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetBuddyDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetBuddyDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetBuddyDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::PerformJumpCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterSectionCsReq::CMD_ID => {
|
|
let mut pb_message = EnterSectionCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerInfoCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetAvatarDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetAvatarDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetAvatarDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
VideoGetInfoCsReq::CMD_ID => {
|
|
let mut pb_message = VideoGetInfoCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::VideoGetInfoCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
FinishArchivePerformScRsp::CMD_ID => {
|
|
let mut pb_message = FinishArchivePerformScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::FinishArchivePerformScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
StartTrainingCsReq::CMD_ID => {
|
|
let mut pb_message = StartTrainingCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::StartTrainingCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
StartHollowQuestCsReq::CMD_ID => {
|
|
let mut pb_message = StartHollowQuestCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::StartHollowQuestCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWebActivityDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetWebActivityDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWebActivityDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWorkbenchDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetWorkbenchDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWorkbenchDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
AbyssGetDataScRsp::CMD_ID => {
|
|
let mut pb_message = AbyssGetDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::AbyssGetDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetExplorationDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetResourceDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetResourceDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetResourceDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::AbyssGetDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetOnlineFriendsListCsReq::CMD_ID => {
|
|
let mut pb_message = GetOnlineFriendsListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetOnlineFriendsListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
RunEventGraphCsReq::CMD_ID => {
|
|
let mut pb_message = RunEventGraphCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::RunEventGraphCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
StartHollowQuestScRsp::CMD_ID => {
|
|
let mut pb_message = StartHollowQuestScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::StartHollowQuestScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRoleCardDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetRoleCardDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRoleCardDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
SavePlayerSystemSettingCsReq::CMD_ID => {
|
|
let mut pb_message = SavePlayerSystemSettingCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::SavePlayerSystemSettingCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRewardBuffDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetRewardBuffDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRewardBuffDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterTrainingRoomCsReq::CMD_ID => {
|
|
let mut pb_message = EnterTrainingRoomCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterTrainingRoomCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetVhsStoreDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetVhsStoreDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetVhsStoreDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
BeginArchiveBattleQuestScRsp::CMD_ID => {
|
|
let mut pb_message = BeginArchiveBattleQuestScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::BeginArchiveBattleQuestScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetServerTimestampScRsp::CMD_ID => {
|
|
let mut pb_message = GetServerTimestampScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetServerTimestampScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetAbyssRewardDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetAbyssRewardDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetAbyssRewardDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetMainCityRevivalDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetMainCityRevivalDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetMainCityRevivalDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
FinishArchivePerformCsReq::CMD_ID => {
|
|
let mut pb_message = FinishArchivePerformCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::FinishArchivePerformCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetResourceDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetResourceDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetResourceDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterSectionCompleteCsReq::CMD_ID => {
|
|
let mut pb_message = EnterSectionCompleteCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCompleteCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetVhsStoreDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetVhsStoreDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetVhsStoreDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EndBattleScRsp::CMD_ID => {
|
|
let mut pb_message = EndBattleScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EndBattleScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetOnlineFriendsListScRsp::CMD_ID => {
|
|
let mut pb_message = GetOnlineFriendsListScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetOnlineFriendsListScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetMiniscapeEntrustDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetMiniscapeEntrustDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetMiniscapeEntrustDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWeaponDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetWeaponDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWeaponDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetAuthkeyCsReq::CMD_ID => {
|
|
let mut pb_message = GetAuthkeyCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetAuthkeyCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetFishingContestDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetFishingContestDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetFishingContestDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetDailyChallengeDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetDailyChallengeDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetDailyChallengeDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
WeaponDressCsReq::CMD_ID => {
|
|
let mut pb_message = WeaponDressCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::WeaponDressCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetRamenDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
RunEventGraphScRsp::CMD_ID => {
|
|
let mut pb_message = RunEventGraphScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::RunEventGraphScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetAvatarDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetJourneyDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetJourneyDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetJourneyDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRidusGotBooDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetRidusGotBooDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRidusGotBooDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetQuestDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetQuestDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetQuestDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetSystemSettingsCsReq::CMD_ID => {
|
|
let mut pb_message = GetSystemSettingsCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetSystemSettingsCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetCampIdleDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetCampIdleDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetCampIdleDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWebActivityDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetWebActivityDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWebActivityDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
ActiveHollowCheckPointCsReq::CMD_ID => {
|
|
let mut pb_message = ActiveHollowCheckPointCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::ActiveHollowCheckPointCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetServerTimestampCsReq::CMD_ID => {
|
|
let mut pb_message = GetServerTimestampCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetServerTimestampCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::PerformEndCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetAuthkeyScRsp::CMD_ID => {
|
|
let mut pb_message = GetAuthkeyScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetAuthkeyScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetQuestionsAnswerGameDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetQuestionsAnswerGameDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetQuestionsAnswerGameDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetUnlockDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetUnlockDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetUnlockDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetSystemSettingsScRsp::CMD_ID => {
|
|
let mut pb_message = GetSystemSettingsScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetSystemSettingsScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
SwitchRoleCsReq::CMD_ID => {
|
|
let mut pb_message = SwitchRoleCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::SwitchRoleCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWishlistDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetWishlistDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWishlistDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetHollowDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetHollowDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetHollowDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
TriggerInteractCsReq::CMD_ID => {
|
|
let mut pb_message = TriggerInteractCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::TriggerInteractCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRedDotListCsReq::CMD_ID => {
|
|
let mut pb_message = GetRedDotListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRedDotListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPrivateMessageDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetPrivateMessageDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPrivateMessageDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterSectionCompleteScRsp::CMD_ID => {
|
|
let mut pb_message = EnterSectionCompleteScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCompleteScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
UndressEquipmentCsReq::CMD_ID => {
|
|
let mut pb_message = UndressEquipmentCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::UndressEquipmentCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
SyncEventInfoScNotify::CMD_ID => {
|
|
let mut pb_message = SyncEventInfoScNotify::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::SyncEventInfoScNotify::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetHadalZoneDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetHadalZoneDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetHadalZoneDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetFashionStoreDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetFashionStoreDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetFashionStoreDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPlayerInfoScRsp::CMD_ID => {
|
|
let mut pb_message = GetPlayerInfoScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerInfoScRsp::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::GetUnlockDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetChatEmojiListScRsp::CMD_ID => {
|
|
let mut pb_message = GetChatEmojiListScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetChatEmojiListScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
DressEquipmentSuitCsReq::CMD_ID => {
|
|
let mut pb_message = DressEquipmentSuitCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::DressEquipmentSuitCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetActivityDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetActivityDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetActivityDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterWorldCsReq::CMD_ID => {
|
|
let mut pb_message = EnterWorldCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterWorldCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetArcadeDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetArcadeDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetArcadeDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
TalentSwitchCsReq::CMD_ID => {
|
|
let mut pb_message = TalentSwitchCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::TalentSwitchCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetEquipDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetEquipDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetEquipDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
RechargeGetItemListCsReq::CMD_ID => {
|
|
let mut pb_message = RechargeGetItemListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::RechargeGetItemListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetCafeDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetCafeDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetCafeDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
PlayerLogoutCsReq::CMD_ID => {
|
|
let mut pb_message = PlayerLogoutCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::PlayerLogoutCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
PlayerOperationCsReq::CMD_ID => {
|
|
let mut pb_message = PlayerOperationCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::PlayerOperationCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetGachaDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetGachaDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetGachaDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWishlistDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetWishlistDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWishlistDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
EnterWorldScRsp::CMD_ID => {
|
|
let mut pb_message = EnterWorldScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::EnterWorldScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetMonthCardRewardListCsReq::CMD_ID => {
|
|
let mut pb_message = GetMonthCardRewardListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetMonthCardRewardListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetTipsDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetTipsDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetTipsDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
PerformTriggerScRsp::CMD_ID => {
|
|
let mut pb_message = PerformTriggerScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::PerformTriggerScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetBattlePassDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetBattlePassDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetBattlePassDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
PostEnterWorldCsReq::CMD_ID => {
|
|
let mut pb_message = PostEnterWorldCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::PostEnterWorldCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetNewsStandDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetNewsStandDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetNewsStandDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetChatEmojiListCsReq::CMD_ID => {
|
|
let mut pb_message = GetChatEmojiListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetChatEmojiListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
PlayerSyncScNotify::CMD_ID => {
|
|
let mut pb_message = PlayerSyncScNotify::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::PlayerSyncScNotify::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetGachaDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetGachaDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetGachaDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetFriendListScRsp::CMD_ID => {
|
|
let mut pb_message = GetFriendListScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetFriendListScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetAvatarRecommendEquipCsReq::CMD_ID => {
|
|
let mut pb_message = GetAvatarRecommendEquipCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetAvatarRecommendEquipCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
UpdateEventGraphScNotify::CMD_ID => {
|
|
let mut pb_message = UpdateEventGraphScNotify::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::UpdateEventGraphScNotify::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
StartTrainingScRsp::CMD_ID => {
|
|
let mut pb_message = StartTrainingScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::StartTrainingScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
RefreshSectionScRsp::CMD_ID => {
|
|
let mut pb_message = RefreshSectionScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::RefreshSectionScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
ReportUiLayoutPlatformCsReq::CMD_ID => {
|
|
let mut pb_message = ReportUiLayoutPlatformCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::ReportUiLayoutPlatformCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetFriendListCsReq::CMD_ID => {
|
|
let mut pb_message = GetFriendListCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetFriendListCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetDisplayCaseDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetDisplayCaseDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetDisplayCaseDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRamenDataScRsp::CMD_ID => {
|
|
let mut pb_message = GetRamenDataScRsp::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRamenDataScRsp::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetRoleCardDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetRoleCardDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetRoleCardDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
ClickHollowSystemCsReq::CMD_ID => {
|
|
let mut pb_message = ClickHollowSystemCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::ClickHollowSystemCsReq::from(
|
|
pb_message,
|
|
);
|
|
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();
|
|
let common_protocol_message = ::trigger_protocol::LeaveCurSceneCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetEquipDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetEquipDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetEquipDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
SceneTransitionCsReq::CMD_ID => {
|
|
let mut pb_message = SceneTransitionCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::SceneTransitionCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetPlayerMailsCsReq::CMD_ID => {
|
|
let mut pb_message = GetPlayerMailsCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerMailsCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetArchiveDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetArchiveDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetArchiveDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
AbyssArpeggioGetDataCsReq::CMD_ID => {
|
|
let mut pb_message = AbyssArpeggioGetDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::AbyssArpeggioGetDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
GetWeaponDataCsReq::CMD_ID => {
|
|
let mut pb_message = GetWeaponDataCsReq::decode(pb)?;
|
|
pb_message.xor_fields();
|
|
let common_protocol_message = ::trigger_protocol::GetWeaponDataCsReq::from(
|
|
pb_message,
|
|
);
|
|
Ok(Some(common_protocol_message.into()))
|
|
}
|
|
_ => Ok(None),
|
|
}
|
|
}
|
|
pub fn common_protocol_unit_to_pb(
|
|
unit: &::trigger_protocol::util::ProtocolUnit,
|
|
) -> ::std::io::Result<Option<(u16, Vec<u8>)>> {
|
|
use ::trigger_encoding::Decodeable;
|
|
use ::trigger_protocol::ClientCmdID;
|
|
match unit.cmd_id {
|
|
::trigger_protocol::GetRewardBuffDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRewardBuffDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRewardBuffDataScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetBuddyDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetBuddyDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::BattleReportCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::BattleReportCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = BattleReportCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = HollowDataRefreshCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((HollowDataRefreshCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::SavePosInMainCityCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::SavePosInMainCityCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = SavePosInMainCityCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((SavePosInMainCityCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPartnerDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPartnerDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPartnerDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPartnerDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EndBattleCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EndBattleCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EndBattleCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EndBattleCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetBattleEventInfoCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetBattleEventInfoCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetBattleEventInfoCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetBattleEventInfoCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetQuestDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetQuestDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetQuestDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetQuestDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterSceneScNotify::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterSceneScNotify::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterSceneScNotify::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterSceneScNotify::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetHollowDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetHollowDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetHollowDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetHollowDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetCharacterQuestListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetCharacterQuestListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetCharacterQuestListCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetCharacterQuestListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetTrashbinHermitDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetTrashbinHermitDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetTrashbinHermitDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetTrashbinHermitDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPhotoWallDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPhotoWallDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPhotoWallDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPhotoWallDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetCafeDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetCafeDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetCafeDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetCafeDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::VideoGetInfoScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::VideoGetInfoScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = VideoGetInfoScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((VideoGetInfoScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetShoppingMallInfoCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetShoppingMallInfoCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetShoppingMallInfoCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetShoppingMallInfoCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::BeginArchiveBattleQuestCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::BeginArchiveBattleQuestCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = BeginArchiveBattleQuestCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((BeginArchiveBattleQuestCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetBabelTowerDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetBabelTowerDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetBabelTowerDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetBabelTowerDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::DressEquipmentCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::DressEquipmentCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = DressEquipmentCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetTipsDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetTipsDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::RefreshSectionCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::RefreshSectionCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = RefreshSectionCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((RefreshSectionCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetActivityDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetActivityDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetActivityDataScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = PerformTriggerCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PerformTriggerCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPhotoWallDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPhotoWallDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPhotoWallDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPhotoWallDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::InteractWithUnitCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::InteractWithUnitCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = InteractWithUnitCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((InteractWithUnitCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::WeaponUnDressCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::WeaponUnDressCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = WeaponUnDressCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((WeaponUnDressCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetArchiveDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetArchiveDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetArchiveDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetArchiveDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPlayerTransactionCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerTransactionCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPlayerTransactionCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPlayerTransactionCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetBuddyDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetBuddyDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetBuddyDataScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = PerformJumpCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PerformJumpCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterSectionCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterSectionCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetPlayerInfoCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPlayerInfoCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetAvatarDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetAvatarDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetAvatarDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAvatarDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::VideoGetInfoCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::VideoGetInfoCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = VideoGetInfoCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((VideoGetInfoCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::FinishArchivePerformScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::FinishArchivePerformScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = FinishArchivePerformScRsp::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((FinishArchivePerformScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::StartTrainingCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::StartTrainingCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = StartTrainingCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((StartTrainingCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::StartHollowQuestCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::StartHollowQuestCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = StartHollowQuestCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((StartHollowQuestCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWebActivityDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWebActivityDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWebActivityDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWebActivityDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWorkbenchDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWorkbenchDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWorkbenchDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWorkbenchDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::AbyssGetDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::AbyssGetDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = AbyssGetDataScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetExplorationDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetExplorationDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetResourceDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetResourceDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetResourceDataCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = AbyssGetDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((AbyssGetDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetOnlineFriendsListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetOnlineFriendsListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetOnlineFriendsListCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetOnlineFriendsListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::RunEventGraphCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::RunEventGraphCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = RunEventGraphCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((RunEventGraphCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::StartHollowQuestScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::StartHollowQuestScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = StartHollowQuestScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((StartHollowQuestScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRoleCardDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRoleCardDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRoleCardDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRoleCardDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::SavePlayerSystemSettingCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::SavePlayerSystemSettingCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = SavePlayerSystemSettingCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((SavePlayerSystemSettingCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRewardBuffDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRewardBuffDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRewardBuffDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRewardBuffDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterTrainingRoomCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterTrainingRoomCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterTrainingRoomCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterTrainingRoomCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetVhsStoreDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetVhsStoreDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetVhsStoreDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetVhsStoreDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::BeginArchiveBattleQuestScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::BeginArchiveBattleQuestScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = BeginArchiveBattleQuestScRsp::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((BeginArchiveBattleQuestScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetServerTimestampScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetServerTimestampScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetServerTimestampScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetServerTimestampScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetAbyssRewardDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetAbyssRewardDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetAbyssRewardDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAbyssRewardDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetMainCityRevivalDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetMainCityRevivalDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetMainCityRevivalDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetMainCityRevivalDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::FinishArchivePerformCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::FinishArchivePerformCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = FinishArchivePerformCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((FinishArchivePerformCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetResourceDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetResourceDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetResourceDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetResourceDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterSectionCompleteCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCompleteCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterSectionCompleteCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterSectionCompleteCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetVhsStoreDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetVhsStoreDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetVhsStoreDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetVhsStoreDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EndBattleScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EndBattleScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EndBattleScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EndBattleScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetOnlineFriendsListScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetOnlineFriendsListScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetOnlineFriendsListScRsp::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetOnlineFriendsListScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetMiniscapeEntrustDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetMiniscapeEntrustDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetMiniscapeEntrustDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetMiniscapeEntrustDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWeaponDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWeaponDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWeaponDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWeaponDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetAuthkeyCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetAuthkeyCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetAuthkeyCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAuthkeyCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetFishingContestDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetFishingContestDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetFishingContestDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetFishingContestDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetDailyChallengeDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetDailyChallengeDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetDailyChallengeDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetDailyChallengeDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::WeaponDressCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::WeaponDressCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = WeaponDressCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetRamenDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRamenDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::RunEventGraphScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::RunEventGraphScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = RunEventGraphScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetAvatarDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAvatarDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetJourneyDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetJourneyDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetJourneyDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetJourneyDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRidusGotBooDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRidusGotBooDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRidusGotBooDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRidusGotBooDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetQuestDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetQuestDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetQuestDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetQuestDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetSystemSettingsCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetSystemSettingsCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetSystemSettingsCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetSystemSettingsCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetCampIdleDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetCampIdleDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetCampIdleDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetCampIdleDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWebActivityDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWebActivityDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWebActivityDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWebActivityDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::ActiveHollowCheckPointCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::ActiveHollowCheckPointCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = ActiveHollowCheckPointCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((ActiveHollowCheckPointCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetServerTimestampCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetServerTimestampCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetServerTimestampCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = PerformEndCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PerformEndCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetAuthkeyScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetAuthkeyScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetAuthkeyScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAuthkeyScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetQuestionsAnswerGameDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetQuestionsAnswerGameDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetQuestionsAnswerGameDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(
|
|
Some((
|
|
GetQuestionsAnswerGameDataCsReq::CMD_ID,
|
|
pb_message.encode_to_vec(),
|
|
)),
|
|
)
|
|
}
|
|
::trigger_protocol::GetUnlockDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetUnlockDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetUnlockDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetUnlockDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetSystemSettingsScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetSystemSettingsScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetSystemSettingsScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetSystemSettingsScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::SwitchRoleCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::SwitchRoleCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = SwitchRoleCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((SwitchRoleCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWishlistDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWishlistDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWishlistDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWishlistDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetHollowDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetHollowDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetHollowDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetHollowDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::TriggerInteractCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::TriggerInteractCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = TriggerInteractCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((TriggerInteractCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRedDotListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRedDotListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRedDotListCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRedDotListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPrivateMessageDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPrivateMessageDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPrivateMessageDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPrivateMessageDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterSectionCompleteScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterSectionCompleteScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterSectionCompleteScRsp::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterSectionCompleteScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::UndressEquipmentCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::UndressEquipmentCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = UndressEquipmentCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((UndressEquipmentCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::SyncEventInfoScNotify::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::SyncEventInfoScNotify::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = SyncEventInfoScNotify::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((SyncEventInfoScNotify::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetHadalZoneDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetHadalZoneDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetHadalZoneDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetHadalZoneDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetFashionStoreDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetFashionStoreDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetFashionStoreDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetFashionStoreDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPlayerInfoScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerInfoScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPlayerInfoScRsp::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = GetUnlockDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetUnlockDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetChatEmojiListScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetChatEmojiListScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetChatEmojiListScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetChatEmojiListScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::DressEquipmentSuitCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::DressEquipmentSuitCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = DressEquipmentSuitCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((DressEquipmentSuitCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetActivityDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetActivityDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetActivityDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetActivityDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterWorldCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterWorldCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterWorldCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterWorldCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetArcadeDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetArcadeDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetArcadeDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetArcadeDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::TalentSwitchCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::TalentSwitchCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = TalentSwitchCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((TalentSwitchCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetEquipDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetEquipDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetEquipDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetEquipDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::RechargeGetItemListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::RechargeGetItemListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = RechargeGetItemListCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((RechargeGetItemListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetCafeDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetCafeDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetCafeDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetCafeDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::PlayerLogoutCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::PlayerLogoutCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = PlayerLogoutCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PlayerLogoutCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::PlayerOperationCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::PlayerOperationCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = PlayerOperationCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PlayerOperationCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetGachaDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetGachaDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetGachaDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetGachaDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWishlistDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWishlistDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWishlistDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWishlistDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::EnterWorldScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::EnterWorldScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = EnterWorldScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((EnterWorldScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetMonthCardRewardListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetMonthCardRewardListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetMonthCardRewardListCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetMonthCardRewardListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetTipsDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetTipsDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetTipsDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetTipsDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::PerformTriggerScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::PerformTriggerScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = PerformTriggerScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PerformTriggerScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetBattlePassDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetBattlePassDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetBattlePassDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetBattlePassDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::PostEnterWorldCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::PostEnterWorldCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = PostEnterWorldCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PostEnterWorldCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetNewsStandDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetNewsStandDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetNewsStandDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetNewsStandDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetChatEmojiListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetChatEmojiListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetChatEmojiListCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetChatEmojiListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::PlayerSyncScNotify::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::PlayerSyncScNotify::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = PlayerSyncScNotify::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((PlayerSyncScNotify::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetGachaDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetGachaDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetGachaDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetGachaDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetFriendListScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetFriendListScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetFriendListScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetFriendListScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetAvatarRecommendEquipCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetAvatarRecommendEquipCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetAvatarRecommendEquipCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetAvatarRecommendEquipCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::UpdateEventGraphScNotify::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::UpdateEventGraphScNotify::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = UpdateEventGraphScNotify::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((UpdateEventGraphScNotify::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::StartTrainingScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::StartTrainingScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = StartTrainingScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((StartTrainingScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::RefreshSectionScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::RefreshSectionScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = RefreshSectionScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((RefreshSectionScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::ReportUiLayoutPlatformCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::ReportUiLayoutPlatformCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = ReportUiLayoutPlatformCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((ReportUiLayoutPlatformCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetFriendListCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetFriendListCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetFriendListCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetFriendListCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetDisplayCaseDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetDisplayCaseDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetDisplayCaseDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetDisplayCaseDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRamenDataScRsp::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRamenDataScRsp::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRamenDataScRsp::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRamenDataScRsp::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetRoleCardDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetRoleCardDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetRoleCardDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetRoleCardDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::ClickHollowSystemCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::ClickHollowSystemCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = ClickHollowSystemCsReq::from(common_protocol_message);
|
|
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),
|
|
)?;
|
|
let mut pb_message = LeaveCurSceneCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((LeaveCurSceneCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetEquipDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetEquipDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetEquipDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetEquipDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::SceneTransitionCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::SceneTransitionCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = SceneTransitionCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((SceneTransitionCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetPlayerMailsCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetPlayerMailsCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetPlayerMailsCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetPlayerMailsCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetArchiveDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetArchiveDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetArchiveDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetArchiveDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::AbyssArpeggioGetDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::AbyssArpeggioGetDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = AbyssArpeggioGetDataCsReq::from(
|
|
common_protocol_message,
|
|
);
|
|
pb_message.xor_fields();
|
|
Ok(Some((AbyssArpeggioGetDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
::trigger_protocol::GetWeaponDataCsReq::CMD_ID => {
|
|
let common_protocol_message = ::trigger_protocol::GetWeaponDataCsReq::decode(
|
|
&mut ::std::io::Cursor::new(&unit.blob),
|
|
)?;
|
|
let mut pb_message = GetWeaponDataCsReq::from(common_protocol_message);
|
|
pb_message.xor_fields();
|
|
Ok(Some((GetWeaponDataCsReq::CMD_ID, pb_message.encode_to_vec())))
|
|
}
|
|
_ => Ok(None),
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRewardBuffDataScRsp> for ::trigger_protocol::GetRewardBuffDataScRsp {
|
|
fn from(value: GetRewardBuffDataScRsp) -> Self {
|
|
Self {
|
|
data: value.data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRewardBuffDataScRsp> for GetRewardBuffDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetRewardBuffDataScRsp) -> Self {
|
|
Self {
|
|
data: value.data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleBeginScRsp> 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<PlayerInfo> for ::trigger_protocol::PlayerInfo {
|
|
fn from(value: PlayerInfo) -> Self {
|
|
Self {
|
|
level: value.level.into(),
|
|
name_change_times: value.name_change_times.into(),
|
|
role_create_time: value.role_create_time.into(),
|
|
avatar_id: value.avatar_id.into(),
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
portrait_id: value.portrait_id.into(),
|
|
nick_name: value.nick_name.into(),
|
|
exp: value.exp.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PlayerInfo> for PlayerInfo {
|
|
fn from(value: ::trigger_protocol::PlayerInfo) -> Self {
|
|
Self {
|
|
level: value.level.into(),
|
|
name_change_times: value.name_change_times.into(),
|
|
role_create_time: value.role_create_time.into(),
|
|
avatar_id: value.avatar_id.into(),
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
portrait_id: value.portrait_id.into(),
|
|
nick_name: value.nick_name.into(),
|
|
exp: value.exp.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetBuddyDataCsReq> for ::trigger_protocol::GetBuddyDataCsReq {
|
|
fn from(value: GetBuddyDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetBuddyDataCsReq> for GetBuddyDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetBuddyDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RamenData> for ::trigger_protocol::RamenData {
|
|
fn from(value: RamenData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RamenData> for RamenData {
|
|
fn from(value: ::trigger_protocol::RamenData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RewardBuffData> for ::trigger_protocol::RewardBuffData {
|
|
fn from(value: RewardBuffData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RewardBuffData> for RewardBuffData {
|
|
fn from(value: ::trigger_protocol::RewardBuffData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BattleReportCsReq> for ::trigger_protocol::BattleReportCsReq {
|
|
fn from(value: BattleReportCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::BattleReportCsReq> for BattleReportCsReq {
|
|
fn from(value: ::trigger_protocol::BattleReportCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<Equip> for ::trigger_protocol::Equip {
|
|
fn from(value: Equip) -> Self {
|
|
Self {
|
|
sub_propertys: value.sub_propertys.into_iter().map(|v| v.into()).collect(),
|
|
star: value.star.into(),
|
|
lock: value.lock.into(),
|
|
level: value.level.into(),
|
|
propertys: value.propertys.into_iter().map(|v| v.into()).collect(),
|
|
id: value.id.into(),
|
|
uid: value.uid.into(),
|
|
exp: value.exp.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::Equip> for Equip {
|
|
fn from(value: ::trigger_protocol::Equip) -> Self {
|
|
Self {
|
|
sub_propertys: value.sub_propertys.into_iter().map(|v| v.into()).collect(),
|
|
star: value.star.into(),
|
|
lock: value.lock.into(),
|
|
level: value.level.into(),
|
|
propertys: value.propertys.into_iter().map(|v| v.into()).collect(),
|
|
id: value.id.into(),
|
|
uid: value.uid.into(),
|
|
exp: value.exp.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SelectRoleCsReq> 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<HollowDataRefreshCsReq> for ::trigger_protocol::HollowDataRefreshCsReq {
|
|
fn from(value: HollowDataRefreshCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowDataRefreshCsReq> for HollowDataRefreshCsReq {
|
|
fn from(value: ::trigger_protocol::HollowDataRefreshCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<LevelPerformInfo> for ::trigger_protocol::LevelPerformInfo {
|
|
fn from(value: LevelPerformInfo) -> Self {
|
|
Self {
|
|
weather: value.weather.into(),
|
|
time: value.time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::LevelPerformInfo> for LevelPerformInfo {
|
|
fn from(value: ::trigger_protocol::LevelPerformInfo) -> Self {
|
|
Self {
|
|
weather: value.weather.into(),
|
|
time: value.time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DressedEquip> for ::trigger_protocol::DressedEquip {
|
|
fn from(value: DressedEquip) -> Self {
|
|
Self {
|
|
index: value.index.into(),
|
|
equip_uid: value.equip_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DressedEquip> for DressedEquip {
|
|
fn from(value: ::trigger_protocol::DressedEquip) -> Self {
|
|
Self {
|
|
index: value.index.into(),
|
|
equip_uid: value.equip_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<LoadingPageTipsInfo> for ::trigger_protocol::LoadingPageTipsInfo {
|
|
fn from(value: LoadingPageTipsInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::LoadingPageTipsInfo> for LoadingPageTipsInfo {
|
|
fn from(value: ::trigger_protocol::LoadingPageTipsInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SavePosInMainCityCsReq> for ::trigger_protocol::SavePosInMainCityCsReq {
|
|
fn from(value: SavePosInMainCityCsReq) -> Self {
|
|
Self {
|
|
section_id: value.section_id.into(),
|
|
position: value.position.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SavePosInMainCityCsReq> for SavePosInMainCityCsReq {
|
|
fn from(value: ::trigger_protocol::SavePosInMainCityCsReq) -> Self {
|
|
Self {
|
|
section_id: value.section_id.into(),
|
|
position: value.position.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AvatarSkillLevel> for ::trigger_protocol::AvatarSkillLevel {
|
|
fn from(value: AvatarSkillLevel) -> Self {
|
|
Self {
|
|
level: value.level.into(),
|
|
skill_type: value.skill_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AvatarSkillLevel> for AvatarSkillLevel {
|
|
fn from(value: ::trigger_protocol::AvatarSkillLevel) -> Self {
|
|
Self {
|
|
level: value.level.into(),
|
|
skill_type: value.skill_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPartnerDataCsReq> for ::trigger_protocol::GetPartnerDataCsReq {
|
|
fn from(value: GetPartnerDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPartnerDataCsReq> for GetPartnerDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetPartnerDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DungeonInfo> for ::trigger_protocol::DungeonInfo {
|
|
fn from(value: DungeonInfo) -> Self {
|
|
Self {
|
|
dungeon_quest_info: value.dungeon_quest_info.map(|v| v.into()),
|
|
quest_id: value.quest_id.into(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
buddy_list: value.buddy_list.into_iter().map(|v| v.into()).collect(),
|
|
dungeon_equip_info: value.dungeon_equip_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DungeonInfo> for DungeonInfo {
|
|
fn from(value: ::trigger_protocol::DungeonInfo) -> Self {
|
|
Self {
|
|
dungeon_quest_info: value.dungeon_quest_info.map(|v| v.into()),
|
|
quest_id: value.quest_id.into(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
buddy_list: value.buddy_list.into_iter().map(|v| v.into()).collect(),
|
|
dungeon_equip_info: value.dungeon_equip_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EndBattleCsReq> for ::trigger_protocol::EndBattleCsReq {
|
|
fn from(value: EndBattleCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EndBattleCsReq> for EndBattleCsReq {
|
|
fn from(value: ::trigger_protocol::EndBattleCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PostGirlInfo> for ::trigger_protocol::PostGirlInfo {
|
|
fn from(value: PostGirlInfo) -> Self {
|
|
Self {
|
|
selected_post_girl_id_list: value
|
|
.selected_post_girl_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
post_girl_item_list: value
|
|
.post_girl_item_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PostGirlInfo> for PostGirlInfo {
|
|
fn from(value: ::trigger_protocol::PostGirlInfo) -> Self {
|
|
Self {
|
|
selected_post_girl_id_list: value
|
|
.selected_post_girl_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
post_girl_item_list: value
|
|
.post_girl_item_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetBattleEventInfoCsReq> for ::trigger_protocol::GetBattleEventInfoCsReq {
|
|
fn from(value: GetBattleEventInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetBattleEventInfoCsReq> for GetBattleEventInfoCsReq {
|
|
fn from(value: ::trigger_protocol::GetBattleEventInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetQuestDataScRsp> for ::trigger_protocol::GetQuestDataScRsp {
|
|
fn from(value: GetQuestDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
quest_type: value.quest_type.into(),
|
|
quest_data: value.quest_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetQuestDataScRsp> for GetQuestDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetQuestDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
quest_type: value.quest_type.into(),
|
|
quest_data: value.quest_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HallSceneInfo> for ::trigger_protocol::HallSceneInfo {
|
|
fn from(value: HallSceneInfo) -> Self {
|
|
Self {
|
|
transform_id: value.transform_id.into(),
|
|
bgm_id: value.bgm_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
time_of_day: value.time_of_day.into(),
|
|
position: value.position.map(|v| v.into()),
|
|
scene_unit_list: value
|
|
.scene_unit_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
day_of_week: value.day_of_week.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HallSceneInfo> for HallSceneInfo {
|
|
fn from(value: ::trigger_protocol::HallSceneInfo) -> Self {
|
|
Self {
|
|
transform_id: value.transform_id.into(),
|
|
bgm_id: value.bgm_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
time_of_day: value.time_of_day.into(),
|
|
position: value.position.map(|v| v.into()),
|
|
scene_unit_list: value
|
|
.scene_unit_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
day_of_week: value.day_of_week.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterSceneScNotify> for ::trigger_protocol::EnterSceneScNotify {
|
|
fn from(value: EnterSceneScNotify) -> Self {
|
|
Self {
|
|
scene: value.scene.map(|v| v.into()),
|
|
dungeon: value.dungeon.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterSceneScNotify> for EnterSceneScNotify {
|
|
fn from(value: ::trigger_protocol::EnterSceneScNotify) -> Self {
|
|
Self {
|
|
scene: value.scene.map(|v| v.into()),
|
|
dungeon: value.dungeon.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PerformInfo> for ::trigger_protocol::PerformInfo {
|
|
fn from(value: PerformInfo) -> Self {
|
|
Self {
|
|
perform_id_list: value
|
|
.perform_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PerformInfo> for PerformInfo {
|
|
fn from(value: ::trigger_protocol::PerformInfo) -> Self {
|
|
Self {
|
|
perform_id_list: value
|
|
.perform_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetHollowDataScRsp> for ::trigger_protocol::GetHollowDataScRsp {
|
|
fn from(value: GetHollowDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
hollow_data: value.hollow_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetHollowDataScRsp> for GetHollowDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetHollowDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
hollow_data: value.hollow_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetCharacterQuestListCsReq>
|
|
for ::trigger_protocol::GetCharacterQuestListCsReq {
|
|
fn from(value: GetCharacterQuestListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetCharacterQuestListCsReq>
|
|
for GetCharacterQuestListCsReq {
|
|
fn from(value: ::trigger_protocol::GetCharacterQuestListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FightSceneInfo> for ::trigger_protocol::FightSceneInfo {
|
|
fn from(value: FightSceneInfo) -> Self {
|
|
Self {
|
|
level_perform_info: value.level_perform_info.map(|v| v.into()),
|
|
end_hollow: value.end_hollow.into(),
|
|
level_reward_info: value.level_reward_info.map(|v| v.into()),
|
|
perform_type: value.perform_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::FightSceneInfo> for FightSceneInfo {
|
|
fn from(value: ::trigger_protocol::FightSceneInfo) -> Self {
|
|
Self {
|
|
level_perform_info: value.level_perform_info.map(|v| v.into()),
|
|
end_hollow: value.end_hollow.into(),
|
|
level_reward_info: value.level_reward_info.map(|v| v.into()),
|
|
perform_type: value.perform_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetTrashbinHermitDataCsReq>
|
|
for ::trigger_protocol::GetTrashbinHermitDataCsReq {
|
|
fn from(value: GetTrashbinHermitDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetTrashbinHermitDataCsReq>
|
|
for GetTrashbinHermitDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetTrashbinHermitDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPhotoWallDataCsReq> for ::trigger_protocol::GetPhotoWallDataCsReq {
|
|
fn from(value: GetPhotoWallDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPhotoWallDataCsReq> for GetPhotoWallDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetPhotoWallDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetCafeDataCsReq> for ::trigger_protocol::GetCafeDataCsReq {
|
|
fn from(value: GetCafeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetCafeDataCsReq> for GetCafeDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetCafeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<VideoGetInfoScRsp> for ::trigger_protocol::VideoGetInfoScRsp {
|
|
fn from(value: VideoGetInfoScRsp) -> Self {
|
|
Self {
|
|
video_key_map: value
|
|
.video_key_map
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::VideoGetInfoScRsp> for VideoGetInfoScRsp {
|
|
fn from(value: ::trigger_protocol::VideoGetInfoScRsp) -> Self {
|
|
Self {
|
|
video_key_map: value
|
|
.video_key_map
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetShoppingMallInfoCsReq> for ::trigger_protocol::GetShoppingMallInfoCsReq {
|
|
fn from(value: GetShoppingMallInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetShoppingMallInfoCsReq> for GetShoppingMallInfoCsReq {
|
|
fn from(value: ::trigger_protocol::GetShoppingMallInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginArchiveBattleQuestCsReq>
|
|
for ::trigger_protocol::BeginArchiveBattleQuestCsReq {
|
|
fn from(value: BeginArchiveBattleQuestCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
buddy_id: value.buddy_id.into(),
|
|
is_story: value.is_story.into(),
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::BeginArchiveBattleQuestCsReq>
|
|
for BeginArchiveBattleQuestCsReq {
|
|
fn from(value: ::trigger_protocol::BeginArchiveBattleQuestCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
buddy_id: value.buddy_id.into(),
|
|
is_story: value.is_story.into(),
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetBabelTowerDataCsReq> for ::trigger_protocol::GetBabelTowerDataCsReq {
|
|
fn from(value: GetBabelTowerDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetBabelTowerDataCsReq> for GetBabelTowerDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetBabelTowerDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AvatarSync> for ::trigger_protocol::AvatarSync {
|
|
fn from(value: AvatarSync) -> Self {
|
|
Self {
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AvatarSync> for AvatarSync {
|
|
fn from(value: ::trigger_protocol::AvatarSync) -> Self {
|
|
Self {
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ActionInfo> for ::trigger_protocol::ActionInfo {
|
|
fn from(value: ActionInfo) -> Self {
|
|
Self {
|
|
action_type: value.action_type.into(),
|
|
body: value.body.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ActionInfo> for ActionInfo {
|
|
fn from(value: ::trigger_protocol::ActionInfo) -> Self {
|
|
Self {
|
|
action_type: value.action_type.into(),
|
|
body: value.body.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DressEquipmentCsReq> for ::trigger_protocol::DressEquipmentCsReq {
|
|
fn from(value: DressEquipmentCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
dress_index: value.dress_index.into(),
|
|
equip_uid: value.equip_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DressEquipmentCsReq> for DressEquipmentCsReq {
|
|
fn from(value: ::trigger_protocol::DressEquipmentCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
dress_index: value.dress_index.into(),
|
|
equip_uid: value.equip_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleBeginCsReq> 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<GetTipsDataScRsp> for ::trigger_protocol::GetTipsDataScRsp {
|
|
fn from(value: GetTipsDataScRsp) -> Self {
|
|
Self {
|
|
data: value.data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetTipsDataScRsp> for GetTipsDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetTipsDataScRsp) -> Self {
|
|
Self {
|
|
data: value.data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AbyssDungeon> for ::trigger_protocol::AbyssDungeon {
|
|
fn from(value: AbyssDungeon) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssDungeon> for AbyssDungeon {
|
|
fn from(value: ::trigger_protocol::AbyssDungeon) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RefreshSectionCsReq> for ::trigger_protocol::RefreshSectionCsReq {
|
|
fn from(value: RefreshSectionCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RefreshSectionCsReq> for RefreshSectionCsReq {
|
|
fn from(value: ::trigger_protocol::RefreshSectionCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetActivityDataScRsp> for ::trigger_protocol::GetActivityDataScRsp {
|
|
fn from(value: GetActivityDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetActivityDataScRsp> for GetActivityDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetActivityDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleEndCsReq> 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<UnlockClueItemScRsp> 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<PerformTriggerCsReq> for ::trigger_protocol::PerformTriggerCsReq {
|
|
fn from(value: PerformTriggerCsReq) -> Self {
|
|
Self {
|
|
perform_type: value.perform_type.into(),
|
|
perform_id: value.perform_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PerformTriggerCsReq> for PerformTriggerCsReq {
|
|
fn from(value: ::trigger_protocol::PerformTriggerCsReq) -> Self {
|
|
Self {
|
|
perform_type: value.perform_type.into(),
|
|
perform_id: value.perform_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ArchiveData> for ::trigger_protocol::ArchiveData {
|
|
fn from(value: ArchiveData) -> Self {
|
|
Self {
|
|
videotaps_info: value.videotaps_info.into_iter().map(|v| v.into()).collect(),
|
|
hollow_archive_id_list: value
|
|
.hollow_archive_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ArchiveData> for ArchiveData {
|
|
fn from(value: ::trigger_protocol::ArchiveData) -> Self {
|
|
Self {
|
|
videotaps_info: value.videotaps_info.into_iter().map(|v| v.into()).collect(),
|
|
hollow_archive_id_list: value
|
|
.hollow_archive_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPhotoWallDataScRsp> for ::trigger_protocol::GetPhotoWallDataScRsp {
|
|
fn from(value: GetPhotoWallDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPhotoWallDataScRsp> for GetPhotoWallDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetPhotoWallDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<InteractWithUnitCsReq> for ::trigger_protocol::InteractWithUnitCsReq {
|
|
fn from(value: InteractWithUnitCsReq) -> Self {
|
|
Self {
|
|
npc_tag_id: value.npc_tag_id.into(),
|
|
interact_id: value.interact_id.into(),
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::InteractWithUnitCsReq> for InteractWithUnitCsReq {
|
|
fn from(value: ::trigger_protocol::InteractWithUnitCsReq) -> Self {
|
|
Self {
|
|
npc_tag_id: value.npc_tag_id.into(),
|
|
interact_id: value.interact_id.into(),
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<WeaponUnDressCsReq> for ::trigger_protocol::WeaponUnDressCsReq {
|
|
fn from(value: WeaponUnDressCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::WeaponUnDressCsReq> for WeaponUnDressCsReq {
|
|
fn from(value: ::trigger_protocol::WeaponUnDressCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<Material> for ::trigger_protocol::Material {
|
|
fn from(value: Material) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
num: value.num.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::Material> for Material {
|
|
fn from(value: ::trigger_protocol::Material) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
num: value.num.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FightSettle> for ::trigger_protocol::FightSettle {
|
|
fn from(value: FightSettle) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::FightSettle> for FightSettle {
|
|
fn from(value: ::trigger_protocol::FightSettle) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetArchiveDataScRsp> for ::trigger_protocol::GetArchiveDataScRsp {
|
|
fn from(value: GetArchiveDataScRsp) -> Self {
|
|
Self {
|
|
archive_data: value.archive_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetArchiveDataScRsp> for GetArchiveDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetArchiveDataScRsp) -> Self {
|
|
Self {
|
|
archive_data: value.archive_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPlayerTransactionCsReq> for ::trigger_protocol::GetPlayerTransactionCsReq {
|
|
fn from(value: GetPlayerTransactionCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPlayerTransactionCsReq> for GetPlayerTransactionCsReq {
|
|
fn from(value: ::trigger_protocol::GetPlayerTransactionCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetBuddyDataScRsp> for ::trigger_protocol::GetBuddyDataScRsp {
|
|
fn from(value: GetBuddyDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetBuddyDataScRsp> for GetBuddyDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetBuddyDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleEndScRsp> 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<Transform> for ::trigger_protocol::Transform {
|
|
fn from(value: Transform) -> Self {
|
|
Self {
|
|
position: value.position.into_iter().map(|v| v.into()).collect(),
|
|
rotation: value.rotation.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::Transform> for Transform {
|
|
fn from(value: ::trigger_protocol::Transform) -> Self {
|
|
Self {
|
|
position: value.position.into_iter().map(|v| v.into()).collect(),
|
|
rotation: value.rotation.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PerformJumpCsReq> for ::trigger_protocol::PerformJumpCsReq {
|
|
fn from(value: PerformJumpCsReq) -> Self {
|
|
Self {
|
|
perform_id: value.perform_id.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
perform_type: value.perform_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PerformJumpCsReq> for PerformJumpCsReq {
|
|
fn from(value: ::trigger_protocol::PerformJumpCsReq) -> Self {
|
|
Self {
|
|
perform_id: value.perform_id.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
perform_type: value.perform_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterSectionCsReq> for ::trigger_protocol::EnterSectionCsReq {
|
|
fn from(value: EnterSectionCsReq) -> Self {
|
|
Self {
|
|
transform_id: value.transform_id.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterSectionCsReq> for EnterSectionCsReq {
|
|
fn from(value: ::trigger_protocol::EnterSectionCsReq) -> Self {
|
|
Self {
|
|
transform_id: value.transform_id.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleRebeginScRsp>
|
|
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<RallySceneInfo> for ::trigger_protocol::RallySceneInfo {
|
|
fn from(value: RallySceneInfo) -> Self {
|
|
Self {
|
|
level_reward_info: value.level_reward_info.map(|v| v.into()),
|
|
cur_check_point: value.cur_check_point.map(|v| v.into()),
|
|
level_perform_info: value.level_perform_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RallySceneInfo> for RallySceneInfo {
|
|
fn from(value: ::trigger_protocol::RallySceneInfo) -> Self {
|
|
Self {
|
|
level_reward_info: value.level_reward_info.map(|v| v.into()),
|
|
cur_check_point: value.cur_check_point.map(|v| v.into()),
|
|
level_perform_info: value.level_perform_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPlayerInfoCsReq> for ::trigger_protocol::GetPlayerInfoCsReq {
|
|
fn from(value: GetPlayerInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPlayerInfoCsReq> for GetPlayerInfoCsReq {
|
|
fn from(value: ::trigger_protocol::GetPlayerInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetAvatarDataScRsp> for ::trigger_protocol::GetAvatarDataScRsp {
|
|
fn from(value: GetAvatarDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAvatarDataScRsp> for GetAvatarDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetAvatarDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<VideoGetInfoCsReq> for ::trigger_protocol::VideoGetInfoCsReq {
|
|
fn from(value: VideoGetInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::VideoGetInfoCsReq> for VideoGetInfoCsReq {
|
|
fn from(value: ::trigger_protocol::VideoGetInfoCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FinishArchivePerformScRsp> for ::trigger_protocol::FinishArchivePerformScRsp {
|
|
fn from(value: FinishArchivePerformScRsp) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
retcode: value.retcode.into(),
|
|
sub_id: value.sub_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::FinishArchivePerformScRsp> for FinishArchivePerformScRsp {
|
|
fn from(value: ::trigger_protocol::FinishArchivePerformScRsp) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
retcode: value.retcode.into(),
|
|
sub_id: value.sub_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<StartTrainingCsReq> for ::trigger_protocol::StartTrainingCsReq {
|
|
fn from(value: StartTrainingCsReq) -> Self {
|
|
Self {
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
special_training_index: value.special_training_index.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::StartTrainingCsReq> for StartTrainingCsReq {
|
|
fn from(value: ::trigger_protocol::StartTrainingCsReq) -> Self {
|
|
Self {
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
special_training_index: value.special_training_index.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<StartHollowQuestCsReq> for ::trigger_protocol::StartHollowQuestCsReq {
|
|
fn from(value: StartHollowQuestCsReq) -> Self {
|
|
Self {
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
is_story: value.is_story.into(),
|
|
quest_id: value.quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::StartHollowQuestCsReq> for StartHollowQuestCsReq {
|
|
fn from(value: ::trigger_protocol::StartHollowQuestCsReq) -> Self {
|
|
Self {
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
is_story: value.is_story.into(),
|
|
quest_id: value.quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWebActivityDataCsReq> for ::trigger_protocol::GetWebActivityDataCsReq {
|
|
fn from(value: GetWebActivityDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWebActivityDataCsReq> for GetWebActivityDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetWebActivityDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWorkbenchDataCsReq> for ::trigger_protocol::GetWorkbenchDataCsReq {
|
|
fn from(value: GetWorkbenchDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWorkbenchDataCsReq> for GetWorkbenchDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetWorkbenchDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AbyssGetDataScRsp> for ::trigger_protocol::AbyssGetDataScRsp {
|
|
fn from(value: AbyssGetDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
abyss_data: value.abyss_data.map(|v| v.into()),
|
|
abyss_dungeon_list: value
|
|
.abyss_dungeon_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
abyss_group_list: value
|
|
.abyss_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssGetDataScRsp> for AbyssGetDataScRsp {
|
|
fn from(value: ::trigger_protocol::AbyssGetDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
abyss_data: value.abyss_data.map(|v| v.into()),
|
|
abyss_dungeon_list: value
|
|
.abyss_dungeon_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
abyss_group_list: value
|
|
.abyss_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginnerbattleRebeginCsReq>
|
|
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<GetExplorationDataCsReq> for ::trigger_protocol::GetExplorationDataCsReq {
|
|
fn from(value: GetExplorationDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetExplorationDataCsReq> for GetExplorationDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetExplorationDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetResourceDataCsReq> for ::trigger_protocol::GetResourceDataCsReq {
|
|
fn from(value: GetResourceDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetResourceDataCsReq> for GetResourceDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetResourceDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AdvanceBeginnerProcedureCsReq>
|
|
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<AbyssGetDataCsReq> for ::trigger_protocol::AbyssGetDataCsReq {
|
|
fn from(value: AbyssGetDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssGetDataCsReq> for AbyssGetDataCsReq {
|
|
fn from(value: ::trigger_protocol::AbyssGetDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetOnlineFriendsListCsReq> for ::trigger_protocol::GetOnlineFriendsListCsReq {
|
|
fn from(value: GetOnlineFriendsListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetOnlineFriendsListCsReq> for GetOnlineFriendsListCsReq {
|
|
fn from(value: ::trigger_protocol::GetOnlineFriendsListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RunEventGraphCsReq> for ::trigger_protocol::RunEventGraphCsReq {
|
|
fn from(value: RunEventGraphCsReq) -> Self {
|
|
Self {
|
|
tag: value.tag.into(),
|
|
owner_id: value.owner_id.into(),
|
|
owner_type: value.owner_type.into(),
|
|
event_graph_uid: value.event_graph_uid.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RunEventGraphCsReq> for RunEventGraphCsReq {
|
|
fn from(value: ::trigger_protocol::RunEventGraphCsReq) -> Self {
|
|
Self {
|
|
tag: value.tag.into(),
|
|
owner_id: value.owner_id.into(),
|
|
owner_type: value.owner_type.into(),
|
|
event_graph_uid: value.event_graph_uid.into(),
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<StartHollowQuestScRsp> for ::trigger_protocol::StartHollowQuestScRsp {
|
|
fn from(value: StartHollowQuestScRsp) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::StartHollowQuestScRsp> for StartHollowQuestScRsp {
|
|
fn from(value: ::trigger_protocol::StartHollowQuestScRsp) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FreshSceneInfo> 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<TipsInfo> for ::trigger_protocol::TipsInfo {
|
|
fn from(value: TipsInfo) -> Self {
|
|
Self {
|
|
tips_group_list: value
|
|
.tips_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
tips_list: value.tips_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::TipsInfo> for TipsInfo {
|
|
fn from(value: ::trigger_protocol::TipsInfo) -> Self {
|
|
Self {
|
|
tips_group_list: value
|
|
.tips_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
tips_list: value.tips_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRoleCardDataScRsp> for ::trigger_protocol::GetRoleCardDataScRsp {
|
|
fn from(value: GetRoleCardDataScRsp) -> Self {
|
|
Self {
|
|
role_card_data: value.role_card_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRoleCardDataScRsp> for GetRoleCardDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetRoleCardDataScRsp) -> Self {
|
|
Self {
|
|
role_card_data: value.role_card_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SavePlayerSystemSettingCsReq>
|
|
for ::trigger_protocol::SavePlayerSystemSettingCsReq {
|
|
fn from(value: SavePlayerSystemSettingCsReq) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
params: value.params.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SavePlayerSystemSettingCsReq>
|
|
for SavePlayerSystemSettingCsReq {
|
|
fn from(value: ::trigger_protocol::SavePlayerSystemSettingCsReq) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
params: value.params.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRewardBuffDataCsReq> for ::trigger_protocol::GetRewardBuffDataCsReq {
|
|
fn from(value: GetRewardBuffDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRewardBuffDataCsReq> for GetRewardBuffDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetRewardBuffDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterTrainingRoomCsReq> for ::trigger_protocol::EnterTrainingRoomCsReq {
|
|
fn from(value: EnterTrainingRoomCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
buddy_id: value.buddy_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterTrainingRoomCsReq> for EnterTrainingRoomCsReq {
|
|
fn from(value: ::trigger_protocol::EnterTrainingRoomCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
avatar_id_list: value.avatar_id_list.into_iter().map(|v| v.into()).collect(),
|
|
buddy_id: value.buddy_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<QuestCollection> for ::trigger_protocol::QuestCollection {
|
|
fn from(value: QuestCollection) -> Self {
|
|
Self {
|
|
quest_type: value.quest_type.into(),
|
|
finished_quest_id_list: value
|
|
.finished_quest_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
quest_list: value.quest_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::QuestCollection> for QuestCollection {
|
|
fn from(value: ::trigger_protocol::QuestCollection) -> Self {
|
|
Self {
|
|
quest_type: value.quest_type.into(),
|
|
finished_quest_id_list: value
|
|
.finished_quest_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
quest_list: value.quest_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PopupWindowInfo> for ::trigger_protocol::PopupWindowInfo {
|
|
fn from(value: PopupWindowInfo) -> Self {
|
|
Self {
|
|
popup_window_list: value
|
|
.popup_window_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PopupWindowInfo> for PopupWindowInfo {
|
|
fn from(value: ::trigger_protocol::PopupWindowInfo) -> Self {
|
|
Self {
|
|
popup_window_list: value
|
|
.popup_window_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetVhsStoreDataScRsp> for ::trigger_protocol::GetVhsStoreDataScRsp {
|
|
fn from(value: GetVhsStoreDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
data: value.data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetVhsStoreDataScRsp> for GetVhsStoreDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetVhsStoreDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
data: value.data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ItemSync> for ::trigger_protocol::ItemSync {
|
|
fn from(value: ItemSync) -> Self {
|
|
Self {
|
|
material_list: value.material_list.into_iter().map(|v| v.into()).collect(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
auto_recovery_info: value
|
|
.auto_recovery_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ItemSync> for ItemSync {
|
|
fn from(value: ::trigger_protocol::ItemSync) -> Self {
|
|
Self {
|
|
material_list: value.material_list.into_iter().map(|v| v.into()).collect(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
auto_recovery_info: value
|
|
.auto_recovery_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BeginArchiveBattleQuestScRsp>
|
|
for ::trigger_protocol::BeginArchiveBattleQuestScRsp {
|
|
fn from(value: BeginArchiveBattleQuestScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
quest_id: value.quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::BeginArchiveBattleQuestScRsp>
|
|
for BeginArchiveBattleQuestScRsp {
|
|
fn from(value: ::trigger_protocol::BeginArchiveBattleQuestScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
quest_id: value.quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<BuddyUnitInfo> for ::trigger_protocol::BuddyUnitInfo {
|
|
fn from(value: BuddyUnitInfo) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
buddy_id: value.buddy_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::BuddyUnitInfo> for BuddyUnitInfo {
|
|
fn from(value: ::trigger_protocol::BuddyUnitInfo) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
buddy_id: value.buddy_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetServerTimestampScRsp> for ::trigger_protocol::GetServerTimestampScRsp {
|
|
fn from(value: GetServerTimestampScRsp) -> Self {
|
|
Self {
|
|
timestamp: value.timestamp.into(),
|
|
retcode: value.retcode.into(),
|
|
utc_offset: value.utc_offset.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetServerTimestampScRsp> for GetServerTimestampScRsp {
|
|
fn from(value: ::trigger_protocol::GetServerTimestampScRsp) -> Self {
|
|
Self {
|
|
timestamp: value.timestamp.into(),
|
|
retcode: value.retcode.into(),
|
|
utc_offset: value.utc_offset.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetAbyssRewardDataCsReq> for ::trigger_protocol::GetAbyssRewardDataCsReq {
|
|
fn from(value: GetAbyssRewardDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAbyssRewardDataCsReq> for GetAbyssRewardDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetAbyssRewardDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AutoRecoveryInfo> for ::trigger_protocol::AutoRecoveryInfo {
|
|
fn from(value: AutoRecoveryInfo) -> Self {
|
|
Self {
|
|
last_recovery_timestamp: value.last_recovery_timestamp.into(),
|
|
buy_times: value.buy_times.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AutoRecoveryInfo> for AutoRecoveryInfo {
|
|
fn from(value: ::trigger_protocol::AutoRecoveryInfo) -> Self {
|
|
Self {
|
|
last_recovery_timestamp: value.last_recovery_timestamp.into(),
|
|
buy_times: value.buy_times.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetMainCityRevivalDataCsReq>
|
|
for ::trigger_protocol::GetMainCityRevivalDataCsReq {
|
|
fn from(value: GetMainCityRevivalDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetMainCityRevivalDataCsReq>
|
|
for GetMainCityRevivalDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetMainCityRevivalDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FinishArchivePerformCsReq> for ::trigger_protocol::FinishArchivePerformCsReq {
|
|
fn from(value: FinishArchivePerformCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
sub_id: value.sub_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::FinishArchivePerformCsReq> for FinishArchivePerformCsReq {
|
|
fn from(value: ::trigger_protocol::FinishArchivePerformCsReq) -> Self {
|
|
Self {
|
|
quest_id: value.quest_id.into(),
|
|
sub_id: value.sub_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<VideotapeInfo> for ::trigger_protocol::VideotapeInfo {
|
|
fn from(value: VideotapeInfo) -> Self {
|
|
Self {
|
|
finished: value.finished.into(),
|
|
archive_file_id: value.archive_file_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::VideotapeInfo> for VideotapeInfo {
|
|
fn from(value: ::trigger_protocol::VideotapeInfo) -> Self {
|
|
Self {
|
|
finished: value.finished.into(),
|
|
archive_file_id: value.archive_file_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetResourceDataScRsp> for ::trigger_protocol::GetResourceDataScRsp {
|
|
fn from(value: GetResourceDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
material_list: value.material_list.into_iter().map(|v| v.into()).collect(),
|
|
auto_recovery_info: value
|
|
.auto_recovery_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetResourceDataScRsp> for GetResourceDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetResourceDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
material_list: value.material_list.into_iter().map(|v| v.into()).collect(),
|
|
auto_recovery_info: value
|
|
.auto_recovery_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterSectionCompleteCsReq> for ::trigger_protocol::EnterSectionCompleteCsReq {
|
|
fn from(value: EnterSectionCompleteCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterSectionCompleteCsReq> for EnterSectionCompleteCsReq {
|
|
fn from(value: ::trigger_protocol::EnterSectionCompleteCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetVhsStoreDataCsReq> for ::trigger_protocol::GetVhsStoreDataCsReq {
|
|
fn from(value: GetVhsStoreDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetVhsStoreDataCsReq> for GetVhsStoreDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetVhsStoreDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EndBattleScRsp> for ::trigger_protocol::EndBattleScRsp {
|
|
fn from(value: EndBattleScRsp) -> Self {
|
|
Self {
|
|
fight_settle: value.fight_settle.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EndBattleScRsp> for EndBattleScRsp {
|
|
fn from(value: ::trigger_protocol::EndBattleScRsp) -> Self {
|
|
Self {
|
|
fight_settle: value.fight_settle.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetOnlineFriendsListScRsp> for ::trigger_protocol::GetOnlineFriendsListScRsp {
|
|
fn from(value: GetOnlineFriendsListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetOnlineFriendsListScRsp> for GetOnlineFriendsListScRsp {
|
|
fn from(value: ::trigger_protocol::GetOnlineFriendsListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetMiniscapeEntrustDataCsReq>
|
|
for ::trigger_protocol::GetMiniscapeEntrustDataCsReq {
|
|
fn from(value: GetMiniscapeEntrustDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetMiniscapeEntrustDataCsReq>
|
|
for GetMiniscapeEntrustDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetMiniscapeEntrustDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWeaponDataScRsp> for ::trigger_protocol::GetWeaponDataScRsp {
|
|
fn from(value: GetWeaponDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWeaponDataScRsp> for GetWeaponDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetWeaponDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetAuthkeyCsReq> for ::trigger_protocol::GetAuthkeyCsReq {
|
|
fn from(value: GetAuthkeyCsReq) -> Self {
|
|
Self {
|
|
offline_verify_value: value.offline_verify_value.into(),
|
|
auth_appid: value.auth_appid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAuthkeyCsReq> for GetAuthkeyCsReq {
|
|
fn from(value: ::trigger_protocol::GetAuthkeyCsReq) -> Self {
|
|
Self {
|
|
offline_verify_value: value.offline_verify_value.into(),
|
|
auth_appid: value.auth_appid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetFishingContestDataCsReq>
|
|
for ::trigger_protocol::GetFishingContestDataCsReq {
|
|
fn from(value: GetFishingContestDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetFishingContestDataCsReq>
|
|
for GetFishingContestDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetFishingContestDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetDailyChallengeDataCsReq>
|
|
for ::trigger_protocol::GetDailyChallengeDataCsReq {
|
|
fn from(value: GetDailyChallengeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetDailyChallengeDataCsReq>
|
|
for GetDailyChallengeDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetDailyChallengeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<WeaponDressCsReq> for ::trigger_protocol::WeaponDressCsReq {
|
|
fn from(value: WeaponDressCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
weapon_uid: value.weapon_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::WeaponDressCsReq> for WeaponDressCsReq {
|
|
fn from(value: ::trigger_protocol::WeaponDressCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
weapon_uid: value.weapon_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EndNewbieScRsp> 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<GetRamenDataCsReq> for ::trigger_protocol::GetRamenDataCsReq {
|
|
fn from(value: GetRamenDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRamenDataCsReq> for GetRamenDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetRamenDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<LevelRewardInfo> for ::trigger_protocol::LevelRewardInfo {
|
|
fn from(value: LevelRewardInfo) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::LevelRewardInfo> for LevelRewardInfo {
|
|
fn from(value: ::trigger_protocol::LevelRewardInfo) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RunEventGraphScRsp> for ::trigger_protocol::RunEventGraphScRsp {
|
|
fn from(value: RunEventGraphScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RunEventGraphScRsp> for RunEventGraphScRsp {
|
|
fn from(value: ::trigger_protocol::RunEventGraphScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HollowInfo> for ::trigger_protocol::HollowInfo {
|
|
fn from(value: HollowInfo) -> Self {
|
|
Self {
|
|
hollow_statistics: value.hollow_statistics.map(|v| v.into()),
|
|
hollow_quest_id: value.hollow_quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowInfo> for HollowInfo {
|
|
fn from(value: ::trigger_protocol::HollowInfo) -> Self {
|
|
Self {
|
|
hollow_statistics: value.hollow_statistics.map(|v| v.into()),
|
|
hollow_quest_id: value.hollow_quest_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<UnlockClueItemCsReq> 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<GetAvatarDataCsReq> for ::trigger_protocol::GetAvatarDataCsReq {
|
|
fn from(value: GetAvatarDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAvatarDataCsReq> for GetAvatarDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetAvatarDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HollowData> for ::trigger_protocol::HollowData {
|
|
fn from(value: HollowData) -> Self {
|
|
Self {
|
|
unlock_hollow_group_list: value
|
|
.unlock_hollow_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
hollow_group_list: value
|
|
.hollow_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
unlock_hollow_id_list: value
|
|
.unlock_hollow_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
hollow_info_list: value
|
|
.hollow_info_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowData> for HollowData {
|
|
fn from(value: ::trigger_protocol::HollowData) -> Self {
|
|
Self {
|
|
unlock_hollow_group_list: value
|
|
.unlock_hollow_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
hollow_group_list: value
|
|
.hollow_group_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
unlock_hollow_id_list: value
|
|
.unlock_hollow_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
hollow_info_list: value
|
|
.hollow_info_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EquipProperty> for ::trigger_protocol::EquipProperty {
|
|
fn from(value: EquipProperty) -> Self {
|
|
Self {
|
|
add_value: value.add_value.into(),
|
|
base_value: value.base_value.into(),
|
|
key: value.key.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EquipProperty> for EquipProperty {
|
|
fn from(value: ::trigger_protocol::EquipProperty) -> Self {
|
|
Self {
|
|
add_value: value.add_value.into(),
|
|
base_value: value.base_value.into(),
|
|
key: value.key.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RoleCardData> for ::trigger_protocol::RoleCardData {
|
|
fn from(value: RoleCardData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RoleCardData> for RoleCardData {
|
|
fn from(value: ::trigger_protocol::RoleCardData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetJourneyDataCsReq> for ::trigger_protocol::GetJourneyDataCsReq {
|
|
fn from(value: GetJourneyDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetJourneyDataCsReq> for GetJourneyDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetJourneyDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SceneUnitProtocolInfo> for ::trigger_protocol::SceneUnitProtocolInfo {
|
|
fn from(value: SceneUnitProtocolInfo) -> Self {
|
|
Self {
|
|
npc_id: value.npc_id.into(),
|
|
is_interactable: value.is_interactable.into(),
|
|
interacts_info: value
|
|
.interacts_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SceneUnitProtocolInfo> for SceneUnitProtocolInfo {
|
|
fn from(value: ::trigger_protocol::SceneUnitProtocolInfo) -> Self {
|
|
Self {
|
|
npc_id: value.npc_id.into(),
|
|
is_interactable: value.is_interactable.into(),
|
|
interacts_info: value
|
|
.interacts_info
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRidusGotBooDataCsReq> for ::trigger_protocol::GetRidusGotBooDataCsReq {
|
|
fn from(value: GetRidusGotBooDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRidusGotBooDataCsReq> for GetRidusGotBooDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetRidusGotBooDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<CafeData> for ::trigger_protocol::CafeData {
|
|
fn from(value: CafeData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::CafeData> for CafeData {
|
|
fn from(value: ::trigger_protocol::CafeData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetQuestDataCsReq> for ::trigger_protocol::GetQuestDataCsReq {
|
|
fn from(value: GetQuestDataCsReq) -> Self {
|
|
Self {
|
|
quest_type: value.quest_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetQuestDataCsReq> for GetQuestDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetQuestDataCsReq) -> Self {
|
|
Self {
|
|
quest_type: value.quest_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetSystemSettingsCsReq> for ::trigger_protocol::GetSystemSettingsCsReq {
|
|
fn from(value: GetSystemSettingsCsReq) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetSystemSettingsCsReq> for GetSystemSettingsCsReq {
|
|
fn from(value: ::trigger_protocol::GetSystemSettingsCsReq) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetCampIdleDataCsReq> for ::trigger_protocol::GetCampIdleDataCsReq {
|
|
fn from(value: GetCampIdleDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetCampIdleDataCsReq> for GetCampIdleDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetCampIdleDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWebActivityDataScRsp> for ::trigger_protocol::GetWebActivityDataScRsp {
|
|
fn from(value: GetWebActivityDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWebActivityDataScRsp> for GetWebActivityDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetWebActivityDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ActiveHollowCheckPointCsReq>
|
|
for ::trigger_protocol::ActiveHollowCheckPointCsReq {
|
|
fn from(value: ActiveHollowCheckPointCsReq) -> Self {
|
|
Self {
|
|
check_point: value.check_point.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ActiveHollowCheckPointCsReq>
|
|
for ActiveHollowCheckPointCsReq {
|
|
fn from(value: ::trigger_protocol::ActiveHollowCheckPointCsReq) -> Self {
|
|
Self {
|
|
check_point: value.check_point.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetServerTimestampCsReq> for ::trigger_protocol::GetServerTimestampCsReq {
|
|
fn from(value: GetServerTimestampCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetServerTimestampCsReq> for GetServerTimestampCsReq {
|
|
fn from(value: ::trigger_protocol::GetServerTimestampCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AdvanceBeginnerProcedureScRsp>
|
|
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<PerformEndCsReq> for ::trigger_protocol::PerformEndCsReq {
|
|
fn from(value: PerformEndCsReq) -> Self {
|
|
Self {
|
|
perform_id: value.perform_id.into(),
|
|
perform_type: value.perform_type.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PerformEndCsReq> for PerformEndCsReq {
|
|
fn from(value: ::trigger_protocol::PerformEndCsReq) -> Self {
|
|
Self {
|
|
perform_id: value.perform_id.into(),
|
|
perform_type: value.perform_type.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetAuthkeyScRsp> for ::trigger_protocol::GetAuthkeyScRsp {
|
|
fn from(value: GetAuthkeyScRsp) -> Self {
|
|
Self {
|
|
auth_appid: value.auth_appid.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAuthkeyScRsp> for GetAuthkeyScRsp {
|
|
fn from(value: ::trigger_protocol::GetAuthkeyScRsp) -> Self {
|
|
Self {
|
|
auth_appid: value.auth_appid.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AbyssData> for ::trigger_protocol::AbyssData {
|
|
fn from(value: AbyssData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssData> for AbyssData {
|
|
fn from(value: ::trigger_protocol::AbyssData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<Weapon> for ::trigger_protocol::Weapon {
|
|
fn from(value: Weapon) -> Self {
|
|
Self {
|
|
uid: value.uid.into(),
|
|
level: value.level.into(),
|
|
id: value.id.into(),
|
|
exp: value.exp.into(),
|
|
lock: value.lock.into(),
|
|
refine_level: value.refine_level.into(),
|
|
star: value.star.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::Weapon> for Weapon {
|
|
fn from(value: ::trigger_protocol::Weapon) -> Self {
|
|
Self {
|
|
uid: value.uid.into(),
|
|
level: value.level.into(),
|
|
id: value.id.into(),
|
|
exp: value.exp.into(),
|
|
lock: value.lock.into(),
|
|
refine_level: value.refine_level.into(),
|
|
star: value.star.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetQuestionsAnswerGameDataCsReq>
|
|
for ::trigger_protocol::GetQuestionsAnswerGameDataCsReq {
|
|
fn from(value: GetQuestionsAnswerGameDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetQuestionsAnswerGameDataCsReq>
|
|
for GetQuestionsAnswerGameDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetQuestionsAnswerGameDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetUnlockDataScRsp> for ::trigger_protocol::GetUnlockDataScRsp {
|
|
fn from(value: GetUnlockDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
data: value.data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetUnlockDataScRsp> for GetUnlockDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetUnlockDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
data: value.data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetSystemSettingsScRsp> for ::trigger_protocol::GetSystemSettingsScRsp {
|
|
fn from(value: GetSystemSettingsScRsp) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
retcode: value.retcode.into(),
|
|
player_settings_map: value
|
|
.player_settings_map
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
settings: value.settings.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetSystemSettingsScRsp> for GetSystemSettingsScRsp {
|
|
fn from(value: ::trigger_protocol::GetSystemSettingsScRsp) -> Self {
|
|
Self {
|
|
r#type: value.r#type.into(),
|
|
retcode: value.retcode.into(),
|
|
player_settings_map: value
|
|
.player_settings_map
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
settings: value.settings.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SwitchRoleCsReq> for ::trigger_protocol::SwitchRoleCsReq {
|
|
fn from(value: SwitchRoleCsReq) -> Self {
|
|
Self {
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SwitchRoleCsReq> for SwitchRoleCsReq {
|
|
fn from(value: ::trigger_protocol::SwitchRoleCsReq) -> Self {
|
|
Self {
|
|
player_avatar_id: value.player_avatar_id.into(),
|
|
control_avatar_id: value.control_avatar_id.into(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWishlistDataCsReq> for ::trigger_protocol::GetWishlistDataCsReq {
|
|
fn from(value: GetWishlistDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWishlistDataCsReq> for GetWishlistDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetWishlistDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AvatarUnitInfo> for ::trigger_protocol::AvatarUnitInfo {
|
|
fn from(value: AvatarUnitInfo) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AvatarUnitInfo> for AvatarUnitInfo {
|
|
fn from(value: ::trigger_protocol::AvatarUnitInfo) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetHollowDataCsReq> for ::trigger_protocol::GetHollowDataCsReq {
|
|
fn from(value: GetHollowDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetHollowDataCsReq> for GetHollowDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetHollowDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<TriggerInteractCsReq> for ::trigger_protocol::TriggerInteractCsReq {
|
|
fn from(value: TriggerInteractCsReq) -> Self {
|
|
Self {
|
|
interact_id: value.interact_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::TriggerInteractCsReq> for TriggerInteractCsReq {
|
|
fn from(value: ::trigger_protocol::TriggerInteractCsReq) -> Self {
|
|
Self {
|
|
interact_id: value.interact_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRedDotListCsReq> for ::trigger_protocol::GetRedDotListCsReq {
|
|
fn from(value: GetRedDotListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRedDotListCsReq> for GetRedDotListCsReq {
|
|
fn from(value: ::trigger_protocol::GetRedDotListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPrivateMessageDataCsReq>
|
|
for ::trigger_protocol::GetPrivateMessageDataCsReq {
|
|
fn from(value: GetPrivateMessageDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPrivateMessageDataCsReq>
|
|
for GetPrivateMessageDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetPrivateMessageDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterSectionCompleteScRsp> for ::trigger_protocol::EnterSectionCompleteScRsp {
|
|
fn from(value: EnterSectionCompleteScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterSectionCompleteScRsp> for EnterSectionCompleteScRsp {
|
|
fn from(value: ::trigger_protocol::EnterSectionCompleteScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<UndressEquipmentCsReq> for ::trigger_protocol::UndressEquipmentCsReq {
|
|
fn from(value: UndressEquipmentCsReq) -> Self {
|
|
Self {
|
|
undress_index_list: value
|
|
.undress_index_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::UndressEquipmentCsReq> for UndressEquipmentCsReq {
|
|
fn from(value: ::trigger_protocol::UndressEquipmentCsReq) -> Self {
|
|
Self {
|
|
undress_index_list: value
|
|
.undress_index_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SyncEventInfoScNotify> for ::trigger_protocol::SyncEventInfoScNotify {
|
|
fn from(value: SyncEventInfoScNotify) -> Self {
|
|
Self {
|
|
action_list: value.action_list.into_iter().map(|v| v.into()).collect(),
|
|
owner_id: value.owner_id.into(),
|
|
npc_interaction: value.npc_interaction.into(),
|
|
tag: value.tag.into(),
|
|
event_graph_uid: value.event_graph_uid.into(),
|
|
owner_type: value.owner_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SyncEventInfoScNotify> for SyncEventInfoScNotify {
|
|
fn from(value: ::trigger_protocol::SyncEventInfoScNotify) -> Self {
|
|
Self {
|
|
action_list: value.action_list.into_iter().map(|v| v.into()).collect(),
|
|
owner_id: value.owner_id.into(),
|
|
npc_interaction: value.npc_interaction.into(),
|
|
tag: value.tag.into(),
|
|
event_graph_uid: value.event_graph_uid.into(),
|
|
owner_type: value.owner_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetHadalZoneDataCsReq> for ::trigger_protocol::GetHadalZoneDataCsReq {
|
|
fn from(value: GetHadalZoneDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetHadalZoneDataCsReq> for GetHadalZoneDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetHadalZoneDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<Avatar> for ::trigger_protocol::Avatar {
|
|
fn from(value: Avatar) -> Self {
|
|
Self {
|
|
passive_skill_level: value.passive_skill_level.into(),
|
|
taken_rank_up_reward_list: value
|
|
.taken_rank_up_reward_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
talent_switch_list: value
|
|
.talent_switch_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
id: value.id.into(),
|
|
first_get_time: value.first_get_time.into(),
|
|
exp: value.exp.into(),
|
|
dressed_equip_list: value
|
|
.dressed_equip_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
unlocked_talent_num: value.unlocked_talent_num.into(),
|
|
avatar_skin_id: value.avatar_skin_id.into(),
|
|
skill_type_level: value
|
|
.skill_type_level
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
level: value.level.into(),
|
|
show_weapon_type: value.show_weapon_type.into(),
|
|
cur_weapon_uid: value.cur_weapon_uid.into(),
|
|
rank: value.rank.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::Avatar> for Avatar {
|
|
fn from(value: ::trigger_protocol::Avatar) -> Self {
|
|
Self {
|
|
passive_skill_level: value.passive_skill_level.into(),
|
|
taken_rank_up_reward_list: value
|
|
.taken_rank_up_reward_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
talent_switch_list: value
|
|
.talent_switch_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
id: value.id.into(),
|
|
first_get_time: value.first_get_time.into(),
|
|
exp: value.exp.into(),
|
|
dressed_equip_list: value
|
|
.dressed_equip_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
unlocked_talent_num: value.unlocked_talent_num.into(),
|
|
avatar_skin_id: value.avatar_skin_id.into(),
|
|
skill_type_level: value
|
|
.skill_type_level
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
level: value.level.into(),
|
|
show_weapon_type: value.show_weapon_type.into(),
|
|
cur_weapon_uid: value.cur_weapon_uid.into(),
|
|
rank: value.rank.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetFashionStoreDataCsReq> for ::trigger_protocol::GetFashionStoreDataCsReq {
|
|
fn from(value: GetFashionStoreDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetFashionStoreDataCsReq> for GetFashionStoreDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetFashionStoreDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPlayerInfoScRsp> for ::trigger_protocol::GetPlayerInfoScRsp {
|
|
fn from(value: GetPlayerInfoScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
player_info: value.player_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPlayerInfoScRsp> for GetPlayerInfoScRsp {
|
|
fn from(value: ::trigger_protocol::GetPlayerInfoScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
player_info: value.player_info.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SelectRoleScRsp> 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<GetUnlockDataCsReq> for ::trigger_protocol::GetUnlockDataCsReq {
|
|
fn from(value: GetUnlockDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetUnlockDataCsReq> for GetUnlockDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetUnlockDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetChatEmojiListScRsp> for ::trigger_protocol::GetChatEmojiListScRsp {
|
|
fn from(value: GetChatEmojiListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetChatEmojiListScRsp> for GetChatEmojiListScRsp {
|
|
fn from(value: ::trigger_protocol::GetChatEmojiListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<UnlockData> for ::trigger_protocol::UnlockData {
|
|
fn from(value: UnlockData) -> Self {
|
|
Self {
|
|
post_girl: value.post_girl.map(|v| v.into()),
|
|
unlock: value.unlock.map(|v| v.into()),
|
|
teleport: value.teleport.map(|v| v.into()),
|
|
hollow_event: value.hollow_event.map(|v| v.into()),
|
|
music_player: value.music_player.map(|v| v.into()),
|
|
perform: value.perform.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::UnlockData> for UnlockData {
|
|
fn from(value: ::trigger_protocol::UnlockData) -> Self {
|
|
Self {
|
|
post_girl: value.post_girl.map(|v| v.into()),
|
|
unlock: value.unlock.map(|v| v.into()),
|
|
teleport: value.teleport.map(|v| v.into()),
|
|
hollow_event: value.hollow_event.map(|v| v.into()),
|
|
music_player: value.music_player.map(|v| v.into()),
|
|
perform: value.perform.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DressEquipmentSuitCsReq> for ::trigger_protocol::DressEquipmentSuitCsReq {
|
|
fn from(value: DressEquipmentSuitCsReq) -> Self {
|
|
Self {
|
|
param_list: value.param_list.into_iter().map(|v| v.into()).collect(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DressEquipmentSuitCsReq> for DressEquipmentSuitCsReq {
|
|
fn from(value: ::trigger_protocol::DressEquipmentSuitCsReq) -> Self {
|
|
Self {
|
|
param_list: value.param_list.into_iter().map(|v| v.into()).collect(),
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HollowCheckPoint> for ::trigger_protocol::HollowCheckPoint {
|
|
fn from(value: HollowCheckPoint) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowCheckPoint> for HollowCheckPoint {
|
|
fn from(value: ::trigger_protocol::HollowCheckPoint) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HollowStatistics> for ::trigger_protocol::HollowStatistics {
|
|
fn from(value: HollowStatistics) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowStatistics> for HollowStatistics {
|
|
fn from(value: ::trigger_protocol::HollowStatistics) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetActivityDataCsReq> for ::trigger_protocol::GetActivityDataCsReq {
|
|
fn from(value: GetActivityDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetActivityDataCsReq> for GetActivityDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetActivityDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<UnlockInfo> for ::trigger_protocol::UnlockInfo {
|
|
fn from(value: UnlockInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::UnlockInfo> for UnlockInfo {
|
|
fn from(value: ::trigger_protocol::UnlockInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterWorldCsReq> for ::trigger_protocol::EnterWorldCsReq {
|
|
fn from(value: EnterWorldCsReq) -> Self {
|
|
Self {
|
|
is_reenter: value.is_reenter.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterWorldCsReq> for EnterWorldCsReq {
|
|
fn from(value: ::trigger_protocol::EnterWorldCsReq) -> Self {
|
|
Self {
|
|
is_reenter: value.is_reenter.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetArcadeDataCsReq> for ::trigger_protocol::GetArcadeDataCsReq {
|
|
fn from(value: GetArcadeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetArcadeDataCsReq> for GetArcadeDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetArcadeDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<TalentSwitchCsReq> for ::trigger_protocol::TalentSwitchCsReq {
|
|
fn from(value: TalentSwitchCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
talent_switch_list: value
|
|
.talent_switch_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::TalentSwitchCsReq> for TalentSwitchCsReq {
|
|
fn from(value: ::trigger_protocol::TalentSwitchCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
talent_switch_list: value
|
|
.talent_switch_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AbyssGroup> for ::trigger_protocol::AbyssGroup {
|
|
fn from(value: AbyssGroup) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssGroup> for AbyssGroup {
|
|
fn from(value: ::trigger_protocol::AbyssGroup) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetEquipDataScRsp> for ::trigger_protocol::GetEquipDataScRsp {
|
|
fn from(value: GetEquipDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetEquipDataScRsp> for GetEquipDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetEquipDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RechargeGetItemListCsReq> for ::trigger_protocol::RechargeGetItemListCsReq {
|
|
fn from(value: RechargeGetItemListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RechargeGetItemListCsReq> for RechargeGetItemListCsReq {
|
|
fn from(value: ::trigger_protocol::RechargeGetItemListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetCafeDataScRsp> for ::trigger_protocol::GetCafeDataScRsp {
|
|
fn from(value: GetCafeDataScRsp) -> Self {
|
|
Self {
|
|
cafe_data: value.cafe_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetCafeDataScRsp> for GetCafeDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetCafeDataScRsp) -> Self {
|
|
Self {
|
|
cafe_data: value.cafe_data.map(|v| v.into()),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PlayerLogoutCsReq> for ::trigger_protocol::PlayerLogoutCsReq {
|
|
fn from(value: PlayerLogoutCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PlayerLogoutCsReq> for PlayerLogoutCsReq {
|
|
fn from(value: ::trigger_protocol::PlayerLogoutCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PlayerOperationCsReq> for ::trigger_protocol::PlayerOperationCsReq {
|
|
fn from(value: PlayerOperationCsReq) -> Self {
|
|
Self {
|
|
data: value.data.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PlayerOperationCsReq> for PlayerOperationCsReq {
|
|
fn from(value: ::trigger_protocol::PlayerOperationCsReq) -> Self {
|
|
Self {
|
|
data: value.data.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<QuestData> for ::trigger_protocol::QuestData {
|
|
fn from(value: QuestData) -> Self {
|
|
Self {
|
|
quest_collection_list: value
|
|
.quest_collection_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::QuestData> for QuestData {
|
|
fn from(value: ::trigger_protocol::QuestData) -> Self {
|
|
Self {
|
|
quest_collection_list: value
|
|
.quest_collection_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetGachaDataCsReq> for ::trigger_protocol::GetGachaDataCsReq {
|
|
fn from(value: GetGachaDataCsReq) -> Self {
|
|
Self {
|
|
gacha_type: value.gacha_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetGachaDataCsReq> for GetGachaDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetGachaDataCsReq) -> Self {
|
|
Self {
|
|
gacha_type: value.gacha_type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWishlistDataScRsp> for ::trigger_protocol::GetWishlistDataScRsp {
|
|
fn from(value: GetWishlistDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWishlistDataScRsp> for GetWishlistDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetWishlistDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<QuestCondProgress> for ::trigger_protocol::QuestCondProgress {
|
|
fn from(value: QuestCondProgress) -> Self {
|
|
Self {
|
|
public_variables: value
|
|
.public_variables
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::QuestCondProgress> for QuestCondProgress {
|
|
fn from(value: ::trigger_protocol::QuestCondProgress) -> Self {
|
|
Self {
|
|
public_variables: value
|
|
.public_variables
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EnterWorldScRsp> for ::trigger_protocol::EnterWorldScRsp {
|
|
fn from(value: EnterWorldScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::EnterWorldScRsp> for EnterWorldScRsp {
|
|
fn from(value: ::trigger_protocol::EnterWorldScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetMonthCardRewardListCsReq>
|
|
for ::trigger_protocol::GetMonthCardRewardListCsReq {
|
|
fn from(value: GetMonthCardRewardListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetMonthCardRewardListCsReq>
|
|
for GetMonthCardRewardListCsReq {
|
|
fn from(value: ::trigger_protocol::GetMonthCardRewardListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetTipsDataCsReq> for ::trigger_protocol::GetTipsDataCsReq {
|
|
fn from(value: GetTipsDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetTipsDataCsReq> for GetTipsDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetTipsDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PerformTriggerScRsp> for ::trigger_protocol::PerformTriggerScRsp {
|
|
fn from(value: PerformTriggerScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PerformTriggerScRsp> for PerformTriggerScRsp {
|
|
fn from(value: ::trigger_protocol::PerformTriggerScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
perform_uid: value.perform_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetBattlePassDataCsReq> for ::trigger_protocol::GetBattlePassDataCsReq {
|
|
fn from(value: GetBattlePassDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetBattlePassDataCsReq> for GetBattlePassDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetBattlePassDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PostEnterWorldCsReq> for ::trigger_protocol::PostEnterWorldCsReq {
|
|
fn from(value: PostEnterWorldCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PostEnterWorldCsReq> for PostEnterWorldCsReq {
|
|
fn from(value: ::trigger_protocol::PostEnterWorldCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PublicVariable> for ::trigger_protocol::PublicVariable {
|
|
fn from(value: PublicVariable) -> Self {
|
|
Self {
|
|
var_int: value.var_int.into(),
|
|
var_number: value.var_number.into(),
|
|
var_str: value.var_str.into(),
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PublicVariable> for PublicVariable {
|
|
fn from(value: ::trigger_protocol::PublicVariable) -> Self {
|
|
Self {
|
|
var_int: value.var_int.into(),
|
|
var_number: value.var_number.into(),
|
|
var_str: value.var_str.into(),
|
|
r#type: value.r#type.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetNewsStandDataCsReq> for ::trigger_protocol::GetNewsStandDataCsReq {
|
|
fn from(value: GetNewsStandDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetNewsStandDataCsReq> for GetNewsStandDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetNewsStandDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<HollowEventUnlockInfo> for ::trigger_protocol::HollowEventUnlockInfo {
|
|
fn from(value: HollowEventUnlockInfo) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::HollowEventUnlockInfo> for HollowEventUnlockInfo {
|
|
fn from(value: ::trigger_protocol::HollowEventUnlockInfo) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DungeonEquipInfo> for ::trigger_protocol::DungeonEquipInfo {
|
|
fn from(value: DungeonEquipInfo) -> Self {
|
|
Self {
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DungeonEquipInfo> for DungeonEquipInfo {
|
|
fn from(value: ::trigger_protocol::DungeonEquipInfo) -> Self {
|
|
Self {
|
|
equip_list: value.equip_list.into_iter().map(|v| v.into()).collect(),
|
|
avatar_list: value.avatar_list.into_iter().map(|v| v.into()).collect(),
|
|
weapon_list: value.weapon_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PostGirlItem> for ::trigger_protocol::PostGirlItem {
|
|
fn from(value: PostGirlItem) -> Self {
|
|
Self {
|
|
unlock_time: value.unlock_time.into(),
|
|
id: value.id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PostGirlItem> for PostGirlItem {
|
|
fn from(value: ::trigger_protocol::PostGirlItem) -> Self {
|
|
Self {
|
|
unlock_time: value.unlock_time.into(),
|
|
id: value.id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetChatEmojiListCsReq> for ::trigger_protocol::GetChatEmojiListCsReq {
|
|
fn from(value: GetChatEmojiListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetChatEmojiListCsReq> for GetChatEmojiListCsReq {
|
|
fn from(value: ::trigger_protocol::GetChatEmojiListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<PlayerSyncScNotify> for ::trigger_protocol::PlayerSyncScNotify {
|
|
fn from(value: PlayerSyncScNotify) -> Self {
|
|
Self {
|
|
avatar_sync: value.avatar_sync.map(|v| v.into()),
|
|
player_info: value.player_info.map(|v| v.into()),
|
|
item_sync: value.item_sync.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::PlayerSyncScNotify> for PlayerSyncScNotify {
|
|
fn from(value: ::trigger_protocol::PlayerSyncScNotify) -> Self {
|
|
Self {
|
|
avatar_sync: value.avatar_sync.map(|v| v.into()),
|
|
player_info: value.player_info.map(|v| v.into()),
|
|
item_sync: value.item_sync.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetGachaDataScRsp> for ::trigger_protocol::GetGachaDataScRsp {
|
|
fn from(value: GetGachaDataScRsp) -> Self {
|
|
Self {
|
|
gacha_type: value.gacha_type.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetGachaDataScRsp> for GetGachaDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetGachaDataScRsp) -> Self {
|
|
Self {
|
|
gacha_type: value.gacha_type.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DressEquipmentParam> for ::trigger_protocol::DressEquipmentParam {
|
|
fn from(value: DressEquipmentParam) -> Self {
|
|
Self {
|
|
equip_uid: value.equip_uid.into(),
|
|
dress_index: value.dress_index.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DressEquipmentParam> for DressEquipmentParam {
|
|
fn from(value: ::trigger_protocol::DressEquipmentParam) -> Self {
|
|
Self {
|
|
equip_uid: value.equip_uid.into(),
|
|
dress_index: value.dress_index.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetFriendListScRsp> for ::trigger_protocol::GetFriendListScRsp {
|
|
fn from(value: GetFriendListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetFriendListScRsp> for GetFriendListScRsp {
|
|
fn from(value: ::trigger_protocol::GetFriendListScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<InteractInfo> for ::trigger_protocol::InteractInfo {
|
|
fn from(value: InteractInfo) -> Self {
|
|
Self {
|
|
scale_w: value.scale_w.into(),
|
|
scale_x: value.scale_x.into(),
|
|
scale_r: value.scale_r.into(),
|
|
scale_y: value.scale_y.into(),
|
|
participators: value
|
|
.participators
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
scale_z: value.scale_z.into(),
|
|
tag_id: value.tag_id.into(),
|
|
name: value.name.into(),
|
|
interact_target_list: value
|
|
.interact_target_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::InteractInfo> for InteractInfo {
|
|
fn from(value: ::trigger_protocol::InteractInfo) -> Self {
|
|
Self {
|
|
scale_w: value.scale_w.into(),
|
|
scale_x: value.scale_x.into(),
|
|
scale_r: value.scale_r.into(),
|
|
scale_y: value.scale_y.into(),
|
|
participators: value
|
|
.participators
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
scale_z: value.scale_z.into(),
|
|
tag_id: value.tag_id.into(),
|
|
name: value.name.into(),
|
|
interact_target_list: value
|
|
.interact_target_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetAvatarRecommendEquipCsReq>
|
|
for ::trigger_protocol::GetAvatarRecommendEquipCsReq {
|
|
fn from(value: GetAvatarRecommendEquipCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetAvatarRecommendEquipCsReq>
|
|
for GetAvatarRecommendEquipCsReq {
|
|
fn from(value: ::trigger_protocol::GetAvatarRecommendEquipCsReq) -> Self {
|
|
Self {
|
|
avatar_id: value.avatar_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<UpdateEventGraphScNotify> for ::trigger_protocol::UpdateEventGraphScNotify {
|
|
fn from(value: UpdateEventGraphScNotify) -> Self {
|
|
Self {
|
|
owner_type: value.owner_type.into(),
|
|
npc_interaction: value.npc_interaction.into(),
|
|
is_event_success: value.is_event_success.into(),
|
|
tag: value.tag.into(),
|
|
event_graph_owner_uid: value.event_graph_owner_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::UpdateEventGraphScNotify> for UpdateEventGraphScNotify {
|
|
fn from(value: ::trigger_protocol::UpdateEventGraphScNotify) -> Self {
|
|
Self {
|
|
owner_type: value.owner_type.into(),
|
|
npc_interaction: value.npc_interaction.into(),
|
|
is_event_success: value.is_event_success.into(),
|
|
tag: value.tag.into(),
|
|
event_graph_owner_uid: value.event_graph_owner_uid.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<StartTrainingScRsp> for ::trigger_protocol::StartTrainingScRsp {
|
|
fn from(value: StartTrainingScRsp) -> Self {
|
|
Self {
|
|
training_uid: value.training_uid.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::StartTrainingScRsp> for StartTrainingScRsp {
|
|
fn from(value: ::trigger_protocol::StartTrainingScRsp) -> Self {
|
|
Self {
|
|
training_uid: value.training_uid.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<RefreshSectionScRsp> for ::trigger_protocol::RefreshSectionScRsp {
|
|
fn from(value: RefreshSectionScRsp) -> Self {
|
|
Self {
|
|
refresh_status: value.refresh_status.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::RefreshSectionScRsp> for RefreshSectionScRsp {
|
|
fn from(value: ::trigger_protocol::RefreshSectionScRsp) -> Self {
|
|
Self {
|
|
refresh_status: value.refresh_status.into(),
|
|
retcode: value.retcode.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ReportUiLayoutPlatformCsReq>
|
|
for ::trigger_protocol::ReportUiLayoutPlatformCsReq {
|
|
fn from(value: ReportUiLayoutPlatformCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ReportUiLayoutPlatformCsReq>
|
|
for ReportUiLayoutPlatformCsReq {
|
|
fn from(value: ::trigger_protocol::ReportUiLayoutPlatformCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetFriendListCsReq> for ::trigger_protocol::GetFriendListCsReq {
|
|
fn from(value: GetFriendListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetFriendListCsReq> for GetFriendListCsReq {
|
|
fn from(value: ::trigger_protocol::GetFriendListCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetDisplayCaseDataCsReq> for ::trigger_protocol::GetDisplayCaseDataCsReq {
|
|
fn from(value: GetDisplayCaseDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetDisplayCaseDataCsReq> for GetDisplayCaseDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetDisplayCaseDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<TeleportUnlockInfo> for ::trigger_protocol::TeleportUnlockInfo {
|
|
fn from(value: TeleportUnlockInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::TeleportUnlockInfo> for TeleportUnlockInfo {
|
|
fn from(value: ::trigger_protocol::TeleportUnlockInfo) -> Self {
|
|
Self {
|
|
unlocked_list: value.unlocked_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<FairyInfo> for ::trigger_protocol::FairyInfo {
|
|
fn from(value: FairyInfo) -> Self {
|
|
Self {
|
|
fairy_groups: value
|
|
.fairy_groups
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
fairy_record_list: value
|
|
.fairy_record_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::FairyInfo> for FairyInfo {
|
|
fn from(value: ::trigger_protocol::FairyInfo) -> Self {
|
|
Self {
|
|
fairy_groups: value
|
|
.fairy_groups
|
|
.into_iter()
|
|
.map(|(k, v)| (k.into(), v.into()))
|
|
.collect(),
|
|
fairy_record_list: value
|
|
.fairy_record_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRamenDataScRsp> for ::trigger_protocol::GetRamenDataScRsp {
|
|
fn from(value: GetRamenDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
ramen_data: value.ramen_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRamenDataScRsp> for GetRamenDataScRsp {
|
|
fn from(value: ::trigger_protocol::GetRamenDataScRsp) -> Self {
|
|
Self {
|
|
retcode: value.retcode.into(),
|
|
ramen_data: value.ramen_data.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetRoleCardDataCsReq> for ::trigger_protocol::GetRoleCardDataCsReq {
|
|
fn from(value: GetRoleCardDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetRoleCardDataCsReq> for GetRoleCardDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetRoleCardDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<ClickHollowSystemCsReq> for ::trigger_protocol::ClickHollowSystemCsReq {
|
|
fn from(value: ClickHollowSystemCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::ClickHollowSystemCsReq> for ClickHollowSystemCsReq {
|
|
fn from(value: ::trigger_protocol::ClickHollowSystemCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<VhsStoreData> for ::trigger_protocol::VhsStoreData {
|
|
fn from(value: VhsStoreData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::VhsStoreData> for VhsStoreData {
|
|
fn from(value: ::trigger_protocol::VhsStoreData) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<EndNewbieCsReq> 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<SystemSettings> for ::trigger_protocol::SystemSettings {
|
|
fn from(value: SystemSettings) -> Self {
|
|
Self {
|
|
systems: value.systems.into_iter().map(|v| v.into()).collect(),
|
|
switch_of_story_mode: value.switch_of_story_mode.into(),
|
|
switch_of_qte: value.switch_of_qte.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SystemSettings> for SystemSettings {
|
|
fn from(value: ::trigger_protocol::SystemSettings) -> Self {
|
|
Self {
|
|
systems: value.systems.into_iter().map(|v| v.into()).collect(),
|
|
switch_of_story_mode: value.switch_of_story_mode.into(),
|
|
switch_of_qte: value.switch_of_qte.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<QuestInfo> for ::trigger_protocol::QuestInfo {
|
|
fn from(value: QuestInfo) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
unlock_time: value.unlock_time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::QuestInfo> for QuestInfo {
|
|
fn from(value: ::trigger_protocol::QuestInfo) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
unlock_time: value.unlock_time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<LeaveCurSceneCsReq> for ::trigger_protocol::LeaveCurSceneCsReq {
|
|
fn from(value: LeaveCurSceneCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::LeaveCurSceneCsReq> for LeaveCurSceneCsReq {
|
|
fn from(value: ::trigger_protocol::LeaveCurSceneCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<DungeonQuestInfo> for ::trigger_protocol::DungeonQuestInfo {
|
|
fn from(value: DungeonQuestInfo) -> Self {
|
|
Self {
|
|
inner_quest_id_list: value
|
|
.inner_quest_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::DungeonQuestInfo> for DungeonQuestInfo {
|
|
fn from(value: ::trigger_protocol::DungeonQuestInfo) -> Self {
|
|
Self {
|
|
inner_quest_id_list: value
|
|
.inner_quest_id_list
|
|
.into_iter()
|
|
.map(|v| v.into())
|
|
.collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetEquipDataCsReq> for ::trigger_protocol::GetEquipDataCsReq {
|
|
fn from(value: GetEquipDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetEquipDataCsReq> for GetEquipDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetEquipDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SceneTransitionCsReq> for ::trigger_protocol::SceneTransitionCsReq {
|
|
fn from(value: SceneTransitionCsReq) -> Self {
|
|
Self {
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::SceneTransitionCsReq> for SceneTransitionCsReq {
|
|
fn from(value: ::trigger_protocol::SceneTransitionCsReq) -> Self {
|
|
Self {
|
|
section_id: value.section_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetPlayerMailsCsReq> for ::trigger_protocol::GetPlayerMailsCsReq {
|
|
fn from(value: GetPlayerMailsCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetPlayerMailsCsReq> for GetPlayerMailsCsReq {
|
|
fn from(value: ::trigger_protocol::GetPlayerMailsCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<MusicPlayerItem> for ::trigger_protocol::MusicPlayerItem {
|
|
fn from(value: MusicPlayerItem) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
seen_time: value.seen_time.into(),
|
|
unlock_time: value.unlock_time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::MusicPlayerItem> for MusicPlayerItem {
|
|
fn from(value: ::trigger_protocol::MusicPlayerItem) -> Self {
|
|
Self {
|
|
id: value.id.into(),
|
|
seen_time: value.seen_time.into(),
|
|
unlock_time: value.unlock_time.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<SceneData> 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(),
|
|
rally_scene_info: value.rally_scene_info.map(|v| v.into()),
|
|
event_id: value.event_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
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(),
|
|
rally_scene_info: value.rally_scene_info.map(|v| v.into()),
|
|
event_id: value.event_id.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetArchiveDataCsReq> for ::trigger_protocol::GetArchiveDataCsReq {
|
|
fn from(value: GetArchiveDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetArchiveDataCsReq> for GetArchiveDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetArchiveDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<AbyssArpeggioGetDataCsReq> for ::trigger_protocol::AbyssArpeggioGetDataCsReq {
|
|
fn from(value: AbyssArpeggioGetDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::AbyssArpeggioGetDataCsReq> for AbyssArpeggioGetDataCsReq {
|
|
fn from(value: ::trigger_protocol::AbyssArpeggioGetDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<GetWeaponDataCsReq> for ::trigger_protocol::GetWeaponDataCsReq {
|
|
fn from(value: GetWeaponDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::GetWeaponDataCsReq> for GetWeaponDataCsReq {
|
|
fn from(value: ::trigger_protocol::GetWeaponDataCsReq) -> Self {
|
|
Self { ..Default::default() }
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<TipsData> for ::trigger_protocol::TipsData {
|
|
fn from(value: TipsData) -> Self {
|
|
Self {
|
|
tips: value.tips.map(|v| v.into()),
|
|
fairy: value.fairy.map(|v| v.into()),
|
|
loading_page_tips: value.loading_page_tips.map(|v| v.into()),
|
|
popup_window: value.popup_window.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::TipsData> for TipsData {
|
|
fn from(value: ::trigger_protocol::TipsData) -> Self {
|
|
Self {
|
|
tips: value.tips.map(|v| v.into()),
|
|
fairy: value.fairy.map(|v| v.into()),
|
|
loading_page_tips: value.loading_page_tips.map(|v| v.into()),
|
|
popup_window: value.popup_window.map(|v| v.into()),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<MusicPlayerInfo> for ::trigger_protocol::MusicPlayerInfo {
|
|
fn from(value: MusicPlayerInfo) -> Self {
|
|
Self {
|
|
music_list: value.music_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
#[allow(unused)]
|
|
impl From<::trigger_protocol::MusicPlayerInfo> for MusicPlayerInfo {
|
|
fn from(value: ::trigger_protocol::MusicPlayerInfo) -> Self {
|
|
Self {
|
|
music_list: value.music_list.into_iter().map(|v| v.into()).collect(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|