+ events messages

This commit is contained in:
Wiktor Mazur
2019-08-05 21:26:30 +02:00
parent 3ebd31a781
commit 7ae7f6e0b7
3 changed files with 194 additions and 31 deletions
+44 -21
View File
@@ -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<bool> {
Some(buf.get_u8() != 0)
}
@@ -132,8 +154,9 @@ fn deserialize_parameter_table(buf: &mut Cursor<&[u8]>) -> HashMap<u8, Value> {
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<Vec<Value>> {
Some(value)
}
pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Option<Value> {
pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Result<Value, DeserializationError> {
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}),
}
}
+149 -9
View File
@@ -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<Message> {
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<Message> {
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<Message> {
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<f32>,
}
impl RegenerationHealthChanged {
fn encode(val: Parameters) -> Option<Message> {
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<Message> {
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,
}
}
}
}
+1 -1
View File
@@ -69,7 +69,7 @@ fn on_message(cursor: &mut Cursor<&[u8]>, msg_len: u32) -> Option<Message> {
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()
}
}