--- a/rust/hedgewars-engine-messages/src/messages.rs Thu Nov 15 15:39:59 2018 -0500
+++ b/rust/hedgewars-engine-messages/src/messages.rs Fri Nov 16 16:32:51 2018 +0100
@@ -25,26 +25,34 @@
TeamControlGained(String),
TeamControlLost(String),
TimeWrap,
+ Taunt(u8),
+ HogSay(String),
+ Heartbeat,
}
#[derive(Debug, PartialEq)]
pub enum UnsyncedEngineMessage {
+ TeamControlGained(String),
+ TeamControlLost(String),
+}
+
+#[derive(Debug, PartialEq)]
+pub enum UnorderedEngineMessage {
Ping,
Pong,
- Say(String),
- Taunt(u8),
- GameType(u8),
+ ChatMessage(String),
+ TeamMessage(String),
+ Error(String),
Warning(String),
StopSyncing,
GameOver,
GameInterrupted,
GameSetupChecksum(String),
- TeamControlGained(String),
- TeamControlLost(String),
+ PauseToggled,
}
-
#[derive(Debug, PartialEq)]
pub enum ConfigEngineMessage {
+ GameType(u8),
ConfigRequest,
SetAmmo(String),
SetScript(String),
@@ -117,19 +125,140 @@
#[derive(Debug, PartialEq)]
pub enum EngineMessage {
- Synced(SyncedEngineMessage, u32),
- Unsynced(UnsyncedEngineMessage),
- Config(ConfigEngineMessage),
Unknown,
Empty,
+ Synced(SyncedEngineMessage, u32),
+ Unsynced(UnsyncedEngineMessage),
+ Unordered(UnorderedEngineMessage),
+ Config(ConfigEngineMessage),
+}
+
+macro_rules! em {
+ [$msg: expr] => {
+ vec![($msg) as u8]
+ };
+}
+
+macro_rules! ems {
+ [$msg: expr, $param: expr] => {
+ {
+ let mut v = vec![($msg) as u8];
+ v.extend(String::into_bytes($param.to_string()).iter());
+ v
+ }
+ };
}
-impl EngineMessage {
- fn from_bytes(buf: &[u8]) -> Self {
- unimplemented!()
+impl SyncedEngineMessage {
+ fn to_bytes(&self) -> Vec<u8> {
+ use self::KeystrokeAction::*;
+ use self::SyncedEngineMessage::*;
+ match self {
+ Left(Press) => em!['L'],
+ Left(Release) => em!['l'],
+ Right(Press) => em!['R'],
+ Right(Release) => em!['r'],
+ Up(Press) => em!['U'],
+ Up(Release) => em!['u'],
+ Down(Press) => em!['D'],
+ Down(Release) => em!['d'],
+ Precise(Press) => em!['Z'],
+ Precise(Release) => em!['z'],
+ Attack(Press) => em!['A'],
+ Attack(Release) => em!['a'],
+ NextTurn => em!['N'],
+ Switch => em!['S'],
+ Timer(t) => vec!['0' as u8 + t],
+ Slot(s) => vec!['~' as u8, *s],
+ SetWeapon(s) => vec!['~' as u8, *s],
+ Put(x, y) => unimplemented!(),
+ CursorMove(x, y) => unimplemented!(),
+ HighJump => em!['J'],
+ LongJump => em!['j'],
+ Skip => em![','],
+ TeamControlGained(str) => ems!['g', str],
+ TeamControlLost(str) => ems!['f', str],
+ Taunt(s) => vec!['t' as u8, *s],
+ HogSay(str) => ems!['h', str],
+ Heartbeat => em!['+'],
+ TimeWrap => unreachable!(),
+ }
}
+}
+impl UnsyncedEngineMessage {
+ fn to_bytes(&self) -> Vec<u8> {
+ use self::UnsyncedEngineMessage::*;
+ match self {
+ TeamControlGained(str) => ems!['G', str],
+ TeamControlLost(str) => ems!['F', str],
+ }
+ }
+}
+
+impl UnorderedEngineMessage {
fn to_bytes(&self) -> Vec<u8> {
unimplemented!()
}
}
+
+impl ConfigEngineMessage {
+ fn to_bytes(&self) -> Vec<u8> {
+ unimplemented!()
+ }
+}
+
+impl EngineMessage {
+ pub const MAX_LEN: u16 = 49215;
+
+ fn to_unwrapped(&self) -> Vec<u8> {
+ use self::EngineMessage::*;
+ match self {
+ Unknown => unreachable!("you're not supposed to construct such messages"),
+ Empty => unreachable!("you're not supposed to construct such messages"),
+ Synced(SyncedEngineMessage::TimeWrap, _) => vec!['#' as u8, 0xff, 0xff],
+ Synced(msg, timestamp) => {
+ let mut v = msg.to_bytes();
+ v.push((*timestamp / 256) as u8);
+ v.push(*timestamp as u8);
+
+ v
+ }
+ Unsynced(msg) => msg.to_bytes(),
+ Unordered(msg) => msg.to_bytes(),
+ Config(msg) => msg.to_bytes(),
+ }
+ }
+
+ pub fn to_bytes(&self) -> Vec<u8> {
+ let mut unwrapped = self.to_unwrapped();
+ let mut size = unwrapped.len();
+
+ if size > EngineMessage::MAX_LEN as usize - 2 {
+ size = EngineMessage::MAX_LEN as usize - 2;
+ unwrapped.truncate(size);
+ }
+
+ if size < 64 {
+ unwrapped.insert(0, size as u8);
+ } else {
+ size -= 64;
+ unwrapped.insert(0, (size / 256 + 64) as u8);
+ unwrapped.insert(1, size as u8);
+ }
+
+ unwrapped
+ }
+}
+
+#[test]
+fn message_contruction() {
+ assert_eq!(
+ EngineMessage::Synced(SyncedEngineMessage::TimeWrap, 0).to_bytes(),
+ vec![3, '#' as u8, 255, 255]
+ );
+ assert_eq!(
+ EngineMessage::Synced(SyncedEngineMessage::NextTurn, 258).to_bytes(),
+ vec![3, 'N' as u8, 1, 2]
+ );
+}
--- a/rust/hedgewars-engine-messages/src/parser.rs Thu Nov 15 15:39:59 2018 -0500
+++ b/rust/hedgewars-engine-messages/src/parser.rs Fri Nov 16 16:32:51 2018 +0100
@@ -1,8 +1,10 @@
-use nom::{*, Err::Error};
+use nom::{Err::Error, *};
use std::str;
-use super::messages::{*, EngineMessage::*, UnsyncedEngineMessage::*, SyncedEngineMessage::*, ConfigEngineMessage::*, KeystrokeAction::*};
-
+use super::messages::{
+ ConfigEngineMessage::*, EngineMessage::*, KeystrokeAction::*, SyncedEngineMessage::*,
+ UnorderedEngineMessage::*, UnsyncedEngineMessage::*, *,
+};
macro_rules! eof_slice (
($i:expr,) => (
@@ -27,7 +29,7 @@
);
named!(synced_message<&[u8], SyncedEngineMessage>, alt!(
- do_parse!(tag!("L") >> (Left(Press)))
+ do_parse!(tag!("L") >> (Left(Press)))
| do_parse!(tag!("l") >> ( Left(Release) ))
| do_parse!(tag!("R") >> ( Right(Press) ))
| do_parse!(tag!("r") >> ( Right(Release) ))
@@ -53,16 +55,26 @@
| do_parse!(tag!("P") >> x: be_i24 >> y: be_i24 >> ( CursorMove(x, y) ))
| do_parse!(tag!("f") >> s: string_tail >> ( SyncedEngineMessage::TeamControlLost(s) ))
| do_parse!(tag!("g") >> s: string_tail >> ( SyncedEngineMessage::TeamControlGained(s) ))
- /*
- Slot(u8),
- SetWeapon(u8),
- */
+ | do_parse!(tag!("h") >> s: string_tail >> ( HogSay(s) ))
+ | do_parse!(tag!("t") >> t: be_u8 >> ( Taunt(t) ))
+ | do_parse!(tag!("w") >> w: be_u8 >> ( SetWeapon(w) ))
+ | do_parse!(tag!("~") >> s: be_u8 >> ( Slot(s) ))
+ | do_parse!(tag!("+") >> ( Heartbeat ))
));
named!(unsynced_message<&[u8], UnsyncedEngineMessage>, alt!(
- do_parse!(tag!("?") >> (Ping))
- | do_parse!(tag!("!") >> (Ping))
- | do_parse!(tag!("esay ") >> s: string_tail >> (Say(s)))
+ do_parse!(tag!("F") >> s: string_tail >> ( UnsyncedEngineMessage::TeamControlLost(s) ))
+ | do_parse!(tag!("G") >> s: string_tail >> ( UnsyncedEngineMessage::TeamControlGained(s) ))
+));
+
+named!(unordered_message<&[u8], UnorderedEngineMessage>, alt!(
+ do_parse!(tag!("?") >> ( Ping ))
+ | do_parse!(tag!("!") >> ( Ping ))
+ | do_parse!(tag!("s") >> s: string_tail >> ( ChatMessage(s)) )
+ | do_parse!(tag!("b") >> s: string_tail >> ( TeamMessage(s)) ) // TODO: wtf is the format
+ | do_parse!(tag!("M") >> s: string_tail >> ( GameSetupChecksum(s)) )
+ | do_parse!(tag!("o") >> ( StopSyncing ))
+ | do_parse!(tag!("I") >> ( PauseToggled ))
));
named!(config_message<&[u8], ConfigEngineMessage>, alt!(
@@ -80,13 +92,12 @@
alt!(
map!(timestamped_message, |(m, t)| Synced(m, t as u32))
| do_parse!(tag!("#") >> (Synced(TimeWrap, 65535)))
+ | map!(unordered_message, |m| Unordered(m))
| map!(unsynced_message, |m| Unsynced(m))
| map!(config_message, |m| Config(m))
| unrecognized_message
));
-
-
named!(length_specifier<&[u8], u16>, alt!(
verify!(map!(take!(1), |a : &[u8]| a[0] as u16), |l| l < 64)
| map!(take!(2), |a| (a[0] as u16 - 64) * 256 + a[1] as u16 + 64)
@@ -114,18 +125,27 @@
assert_eq!(length_specifier(b"\x00"), Ok((&b""[..], 0)));
assert_eq!(length_specifier(b"\x3f"), Ok((&b""[..], 63)));
assert_eq!(length_specifier(b"\x40\x00"), Ok((&b""[..], 64)));
- assert_eq!(length_specifier(b"\xff\xff"), Ok((&b""[..], 49215)));
+ assert_eq!(
+ length_specifier(b"\xff\xff"),
+ Ok((&b""[..], EngineMessage::MAX_LEN))
+ );
}
#[test]
fn parse_synced_messages() {
- assert_eq!(message(b"\x03L\x01\x02"), Ok((&b""[..], Synced(Left(Press), 258))));
+ assert_eq!(
+ message(b"\x03L\x01\x02"),
+ Ok((&b""[..], Synced(Left(Press), 258)))
+ );
assert_eq!(message(b"\x01#"), Ok((&b""[..], Synced(TimeWrap, 65535))));
}
#[test]
fn parse_unsynced_messages() {
- assert_eq!(message(b"\x0aesay hello"), Ok((&b""[..], Unsynced(Say(String::from("hello"))))));
+ assert_eq!(
+ message(b"\x06shello"),
+ Ok((&b""[..], Unordered(ChatMessage(String::from("hello")))))
+ );
}
#[test]
@@ -139,14 +159,9 @@
#[test]
fn parse_config_messages() {
- assert_eq!(
- message(b"\x01C"),
- Ok((
- &b""[..],
- Config(ConfigRequest)
- ))
- );
+ assert_eq!(message(b"\x01C"), Ok((&b""[..], Config(ConfigRequest))));
}
+
#[test]
fn parse_test_general() {
assert_eq!(string_tail(b"abc"), Ok((&b""[..], String::from("abc"))));