From 7ae7f6e0b75554b81f749964374971fac8d47540 Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Mon, 5 Aug 2019 21:26:30 +0200 Subject: [PATCH] + events messages --- lib/protocol16/src/lib.rs | 65 +++++++++----- src/game_protocol/message.rs | 158 ++++++++++++++++++++++++++++++++-- src/game_protocol/protocol.rs | 2 +- 3 files changed, 194 insertions(+), 31 deletions(-) diff --git a/lib/protocol16/src/lib.rs b/lib/protocol16/src/lib.rs index 4910c32..8f131aa 100644 --- a/lib/protocol16/src/lib.rs +++ b/lib/protocol16/src/lib.rs @@ -8,12 +8,34 @@ use bytes::Buf; mod types; use std::io::Read; +use std::error; +use std::fmt; use types::TypeCode; pub use types::Parameters; pub use types::Value; + +#[derive(Debug, Clone)] +pub struct DeserializationError +{ + type_code: u8 +} + +impl fmt::Display for DeserializationError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Failed to deserialize type_code {}", self.type_code) + } +} + +impl error::Error for DeserializationError { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + None + } +} + + pub fn deserialize_boolean(buf: &mut Cursor<&[u8]>) -> Option { Some(buf.get_u8() != 0) } @@ -132,8 +154,9 @@ fn deserialize_parameter_table(buf: &mut Cursor<&[u8]>) -> HashMap { let key_type_code = buf.get_u8(); let value_type_code = buf.get_u8(); let val = deserialize(value_type_code, buf); - - value.insert(key_type_code, val.unwrap()); + if let Ok(val) = val { + value.insert(key_type_code, val); + } } value @@ -190,26 +213,26 @@ pub fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> Option> { Some(value) } -pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Option { +pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Result { match TypeCode::from(type_code) { - TypeCode::Null => Some(Value::None), - TypeCode::Boolean => if let Some(v) = deserialize_boolean(buf) {Some(Value::Boolean(v))} else {None}, - TypeCode::Byte => if let Some(v) = deserialize_byte(buf) {Some(Value::Byte(v))} else {None}, - TypeCode::Double => if let Some(v) = deserialize_double(buf) {Some(Value::Double(v))} else {None}, - TypeCode::Float => if let Some(v) = deserialize_float(buf) {Some(Value::Float(v))} else {None}, - TypeCode::Integer => if let Some(v) = deserialize_integer(buf) {Some(Value::Integer(v))} else {None}, - TypeCode::Long => if let Some(v) = deserialize_long(buf) {Some(Value::Long(v))} else {None}, - TypeCode::Short => if let Some(v) = deserialize_short(buf) {Some(Value::Short(v))} else {None}, - TypeCode::String => if let Some(v) = deserialize_string(buf) {Some(Value::String(v))} else {None}, - TypeCode::StringArray => if let Some(v) = deserialize_string_array(buf) {Some(Value::StringArray(v))} else {None}, - TypeCode::ByteArray => if let Some(v) = deserialize_byte_array(buf) {Some(Value::ByteArray(v))} else {None}, - TypeCode::Array => if let Some(v) = deserialize_array(buf) {Some(Value::Array(v))} else {None}, - TypeCode::Dictionary => if let Some(v) = deserialize_dictionary(buf) {Some(Value::Dictionary(v))} else {None}, - TypeCode::OperationRequest => if let Some(v) = deserialize_operation_request(buf) {Some(Value::OperationRequest(v))} else {None}, - TypeCode::OperationResponse => if let Some(v) = deserialize_operation_response(buf) {Some(Value::OperationResponse(v))} else {None}, - TypeCode::EventData => if let Some(v) = deserialize_event_data(buf) {Some(Value::EventData(v))} else {None}, - TypeCode::ObjectArray => if let Some(v) = deserialize_object_array(buf) {Some(Value::ObjectArray(v))} else {None}, - _ => panic!("Unimplemented type code {}", type_code), + TypeCode::Null => Ok(Value::None), + TypeCode::Boolean => if let Some(v) = deserialize_boolean(buf) {Ok(Value::Boolean(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Byte => if let Some(v) = deserialize_byte(buf) {Ok(Value::Byte(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Double => if let Some(v) = deserialize_double(buf) {Ok(Value::Double(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Float => if let Some(v) = deserialize_float(buf) {Ok(Value::Float(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Integer => if let Some(v) = deserialize_integer(buf) {Ok(Value::Integer(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Long => if let Some(v) = deserialize_long(buf) {Ok(Value::Long(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Short => if let Some(v) = deserialize_short(buf) {Ok(Value::Short(v))} else {Err(DeserializationError{type_code})}, + TypeCode::String => if let Some(v) = deserialize_string(buf) {Ok(Value::String(v))} else {Err(DeserializationError{type_code})}, + TypeCode::StringArray => if let Some(v) = deserialize_string_array(buf) {Ok(Value::StringArray(v))} else {Err(DeserializationError{type_code})}, + TypeCode::ByteArray => if let Some(v) = deserialize_byte_array(buf) {Ok(Value::ByteArray(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Array => if let Some(v) = deserialize_array(buf) {Ok(Value::Array(v))} else {Err(DeserializationError{type_code})}, + TypeCode::Dictionary => if let Some(v) = deserialize_dictionary(buf) {Ok(Value::Dictionary(v))} else {Err(DeserializationError{type_code})}, + TypeCode::OperationRequest => if let Some(v) = deserialize_operation_request(buf) {Ok(Value::OperationRequest(v))} else {Err(DeserializationError{type_code})}, + TypeCode::OperationResponse => if let Some(v) = deserialize_operation_response(buf) {Ok(Value::OperationResponse(v))} else {Err(DeserializationError{type_code})}, + TypeCode::EventData => if let Some(v) = deserialize_event_data(buf) {Ok(Value::EventData(v))} else {Err(DeserializationError{type_code})}, + TypeCode::ObjectArray => if let Some(v) = deserialize_object_array(buf) {Ok(Value::ObjectArray(v))} else {Err(DeserializationError{type_code})}, + _ => Err(DeserializationError{type_code}), } } diff --git a/src/game_protocol/message.rs b/src/game_protocol/message.rs index 44ed7fd..1ae5677 100644 --- a/src/game_protocol/message.rs +++ b/src/game_protocol/message.rs @@ -1,34 +1,174 @@ +use log::*; + +use super::packet::Packet; use protocol16::Parameters; use protocol16::Value; -use super::packet::Packet; + +macro_rules! deserialize_number { + ($val:expr, $index:expr, $name:expr) => { + if let Some(p) = $val.get(&$index) { + match p { + Value::Short(v) => Some(*v as usize), + Value::Integer(v) => Some(*v as usize), + _ => { + error!("Failed to deserialize {}", $name); + None + } + } + } else { + error!("Index {} not found in {}", $index, $name); + None + } + }; +} + +macro_rules! deserialize_string { + ($val:expr, $index:expr, $name:expr) => { + if let Some(p) = $val.get(&$index) { + match p { + Value::String(v) => Some(v.clone()), + _ => { + error!("Failed to deserialize {}", $name); + None + } + } + } else { + None + } + }; +} + +macro_rules! deserialize_float { + ($val:expr, $index:expr, $name:expr) => { + if let Some(p) = $val.get(&$index) { + match p { + Value::Float(v) => Some(*v as f32), + _ => { + error!("Failed to deserialize {}", $name); + None + } + } + } else { + None + } + }; +} + #[derive(Debug)] pub struct ChatSay { pub source: usize, pub source_name: String, - pub text: String + pub text: String, } impl ChatSay { fn encode(val: Parameters) -> Option { - let source = if let Value::Short(v) = val.get(&0)? { *v as usize } else { return None }; - let source_name = if let Value::String(v) = val.get(&1)? { v.clone() } else { return None }; - let text = if let Value::String(v) = val.get(&2)? { v.clone() } else { return None }; + let source = deserialize_number!(val, 0, "ChatSay::source")?; + let source_name = deserialize_string!(val, 1, "ChatSay::source_name")?; + let text = deserialize_string!(val, 2, "ChatSay::text")?; + Some(Message::ChatSay(Self { + source, + source_name, + text, + })) + } +} - Some(Message::ChatSay(Self {source, source_name, text})) +#[derive(Debug)] +pub struct NewCharacter { + pub source: usize, + pub character_name: String, + pub health: f32, + pub max_health: f32, + pub energy: f32, + pub max_energy: f32, +} + +impl NewCharacter { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 0, "NewCharacter::source")?; + + let character_name = deserialize_string!(val, 1, "NewCharacter::character_name")?; + + let health = deserialize_float!(val, 18, "NewCharacter::health")?; + let max_health = deserialize_float!(val, 19, "NewCharacter::max_health")?; + + let energy = deserialize_float!(val, 22, "NewCharacter::energy")?; + let max_energy = deserialize_float!(val, 23, "NewCharacter::max_energy")?; + + Some(Message::NewCharacter(Self { + source, + character_name, + health, + max_health, + energy, + max_energy, + })) + } +} + +#[derive(Debug)] +pub struct HealthUpdate { + pub source: usize, + pub target: usize, + pub value: f32, +} + +impl HealthUpdate { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 0, "HealthUpdate::source")?; + let target = deserialize_number!(val, 6, "HealthUpdate::target")?; + let value = deserialize_float!(val, 2, "HealthUpdate::value")?; + + Some(Message::HealthUpdate(Self { + source, + target, + value, + })) + } +} + +#[derive(Debug)] +pub struct RegenerationHealthChanged { + pub source: usize, + pub health: f32, + pub max_health: f32, + pub regeneration_rate: Option, +} + +impl RegenerationHealthChanged { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 0, "RegenerationHealthChanged::source")?; + let health = deserialize_float!(val, 2, "RegenerationHealthChanged::health")?; + let max_health = deserialize_float!(val, 3, "RegenerationHealthChanged::max_health")?; + let regeneration_rate = deserialize_float!(val, 4, "RegenerationHealthChanged::regeneration_rate"); + + Some(Message::RegenerationHealthChanged(Self { + source, + health, + max_health, + regeneration_rate, + })) } } #[derive(Debug)] pub enum Message { - ChatSay(ChatSay) + ChatSay(ChatSay), + NewCharacter(NewCharacter), + HealthUpdate(HealthUpdate), + RegenerationHealthChanged(RegenerationHealthChanged), } impl Packet { pub fn decode(self) -> Option { match self.code { + 6 => HealthUpdate::encode(self.parameters), + 24 => NewCharacter::encode(self.parameters), 63 => ChatSay::encode(self.parameters), - _ => None + 79 => RegenerationHealthChanged::encode(self.parameters), + _ => None, } } -} \ No newline at end of file +} diff --git a/src/game_protocol/protocol.rs b/src/game_protocol/protocol.rs index f349b1b..c69e2c9 100644 --- a/src/game_protocol/protocol.rs +++ b/src/game_protocol/protocol.rs @@ -69,7 +69,7 @@ fn on_message(cursor: &mut Cursor<&[u8]>, msg_len: u32) -> Option { if event_data.code != 2 && event_data.parameters.get(&252u8).is_some() { if let protocol16::Value::Short(code) = event_data.parameters.get(&252u8)? { let packet = Packet{code: *code as usize, parameters: event_data.parameters}; - debug!("{:?}", packet); + debug!("[{}] {:?}", packet.code, packet); message = packet.decode() } }