build.rs refactored

This commit is contained in:
Wiktor Mazur
2020-02-18 11:50:17 +01:00
parent a3059c8761
commit d73f34a33b
10 changed files with 7142 additions and 142 deletions
+69 -72
View File
@@ -1,4 +1,3 @@
use std::env;
use std::fs::File; use std::fs::File;
use std::io::Write; use std::io::Write;
use std::path::Path; use std::path::Path;
@@ -69,12 +68,12 @@ fn main() {
fn generate_messages() -> String { fn generate_messages() -> String {
let mut out = String::new(); let mut out = String::new();
out.push_str(r" out.push_str(r"use log::*;
use log::*; use crate::game_messages::Items;
use crate::game_protocol::Items; use photon_decode::Parameters;
use photon_decode::Parameters; use photon_decode::Value;
use photon_decode::Value;
"); ");
out.push_str(include_str!("assets/decode_macros.rs")); out.push_str(include_str!("assets/decode_macros.rs"));
let messages: Messages = serde_json::from_str(include_str!("assets/messages.json")).expect("Missing assets/messages.json"); let messages: Messages = serde_json::from_str(include_str!("assets/messages.json")).expect("Missing assets/messages.json");
@@ -83,30 +82,30 @@ fn generate_messages() -> String {
let mut struct_params = String::new(); let mut struct_params = String::new();
for param in &msg.params { for param in &msg.params {
if param.optional.is_some() { if param.optional.is_some() {
struct_params.push_str(&format!("pub {}: Option<{}>,\n", param.name, param.param_type.rust_type())); struct_params.push_str(&format!(" pub {}: Option<{}>,\n", param.name, param.param_type.rust_type()));
} else { } else {
struct_params.push_str(&format!("pub {}: {},\n", param.name, param.param_type.rust_type())); struct_params.push_str(&format!(" pub {}: {},\n", param.name, param.param_type.rust_type()));
} }
} }
out.push_str(&format!(r###" out.push_str(&format!(r###"
#[derive(Debug)] #[derive(Debug, Default)]
pub struct {} {{ pub struct {} {{
{} {}
}} }}
"###, msg.name, struct_params)); "###, msg.name, struct_params));
let mut parse_body = String::new(); let mut parse_body = String::new();
for param in &msg.params { for param in &msg.params {
if param.param_type == ParamType::Items { if param.param_type == ParamType::Items {
parse_body.push_str(&format!("let {} = {}(val, {}, \"{}::{0}\")?;\n", "item_array", param.param_type.parse_macro(), param.id, msg.name)); parse_body.push_str(&format!(" let {} = {}(val, {}, \"{}::{0}\")?;\n", "item_array", param.param_type.parse_macro(), param.id, msg.name));
parse_body.push_str(&format!("let items = Items::from(&item_array);\n")); parse_body.push_str(&format!(" let items = item_array.into();\n"));
} else { } else {
if param.optional.is_some() { if param.optional.is_some() {
parse_body.push_str(&format!("let {} = {}(val, {}, \"{}::{0}\");\n", param.name, param.param_type.parse_macro(), param.id, msg.name)); parse_body.push_str(&format!(" let {} = {}(val, {}, \"{}::{0}\");\n", param.name, param.param_type.parse_macro(), param.id, msg.name));
} else { } else {
parse_body.push_str(&format!("let {} = {}(val, {}, \"{}::{0}\")?;\n", param.name, param.param_type.parse_macro(), param.id, msg.name)); parse_body.push_str(&format!(" let {} = {}(val, {}, \"{}::{0}\")?;\n", param.name, param.param_type.parse_macro(), param.id, msg.name));
} }
} }
@@ -118,22 +117,21 @@ fn generate_messages() -> String {
} }
out.push_str(&format!(r###" out.push_str(&format!(r###"
impl {0} {{ impl {0} {{
pub fn parse(val: Parameters) -> Option<Message> {{ pub fn parse(val: Parameters) -> Option<Message> {{
info!("{0} parameters: {{:?}}", val); info!("{0} parameters: {{:?}}", val);
{1} {1}
Some(Message::{0}({0} {{ {2} }})) Some(Message::{0}({0} {{ {2} }}))
}} }}
}} }}
"###, msg.name, parse_body, param_names)); "###, msg.name, parse_body, param_names));
} }
out.push_str("#[derive(Debug)]\n"); out.push_str("\n#[derive(Debug)]\n");
out.push_str("pub enum Message {\n"); out.push_str("pub enum Message {\n");
for msg in &[&messages.events[..], &messages.responses[..]].concat() { for msg in &[&messages.events[..], &messages.responses[..]].concat() {
out.push_str(&format!(r###" out.push_str(&format!(" {0}({0}),\n", msg.name));
{0}({0}),"###, msg.name));
} }
out.push_str("}"); out.push_str("}");
@@ -141,58 +139,59 @@ fn generate_messages() -> String {
let mut responses_matches = String::new(); let mut responses_matches = String::new();
for msg in &messages.events { for msg in &messages.events {
event_matches.push_str(&format!("Some(photon_decode::Value::Short({})) => {}::parse(parameters),\n", msg.code, msg.name)); event_matches.push_str(&format!(" Some(photon_decode::Value::Short({})) => {}::parse(parameters),\n", msg.code, msg.name));
} }
for msg in &messages.responses { for msg in &messages.responses {
responses_matches.push_str(&format!("Some(photon_decode::Value::Short({})) => {}::parse(parameters),\n", msg.code, msg.name)); responses_matches.push_str(&format!(" Some(photon_decode::Value::Short({})) => {}::parse(parameters),\n", msg.code, msg.name));
} }
out.push_str(&format!(r###" out.push_str(&format!(r###"
pub fn into_game_message(photon_message: photon_decode::Message) -> Option<Message> {{
debug!("Raw photon : {{:?}}", photon_message); pub fn into_game_message(photon_message: photon_decode::Message) -> Option<Message> {{
match photon_message {{ debug!("Raw photon : {{:?}}", photon_message);
photon_decode::Message::Event(photon_decode::EventData{{ match photon_message {{
code: 1, photon_decode::Message::Event(photon_decode::EventData{{
parameters code: 1,
}}) => {{ parameters
match parameters.get(&252u8) {{ }}) => {{
{} match parameters.get(&252u8) {{
_ => None {}
}} _ => None
}}, }}
photon_decode::Message::Request(photon_decode::OperationRequest{{ }},
code: 1, photon_decode::Message::Request(photon_decode::OperationRequest{{
parameters code: 1,
}}) => {{ parameters
match parameters.get(&253u8) {{ }}) => {{
_ => None match parameters.get(&253u8) {{
}} _ => None
}}, }}
photon_decode::Message::Response(photon_decode::OperationResponse{{ }},
code: 1, photon_decode::Message::Response(photon_decode::OperationResponse{{
parameters, code: 1,
return_code: _, parameters,
debug_message: _ return_code: _,
}}) => {{ debug_message: _
match parameters.get(&253u8) {{ }}) => {{
{} match parameters.get(&253u8) {{
_ => None {}
}} _ => None
}}, }}
_ => None }},
}} _ => None
}} }}
"###, event_matches, responses_matches)); }}
"###, event_matches, responses_matches));
out out
} }
fn generate_itemdb() -> String { fn generate_itemdb() -> String {
let mut out = String::new(); let mut out = String::new();
out.push_str("use std::collections::HashMap;\n"); out.push_str("use std::collections::HashMap;\n\n");
out.push_str("lazy_static! {\n"); out.push_str("lazy_static! {\n");
out.push_str("pub static ref ITEMDB: HashMap<u32, &'static str> = {[\n"); out.push_str(" pub static ref ITEMDB: HashMap<u32, &'static str> = {[\n");
include_str!("assets/item_ids.txt").split('\n').filter_map(|line| { include_str!("assets/item_ids.txt").split('\n').filter_map(|line| {
let v: Vec<&str> = line.split(',').collect(); let v: Vec<&str> = line.split(',').collect();
@@ -200,18 +199,16 @@ fn generate_itemdb() -> String {
let item = v.get(1)?.to_owned(); let item = v.get(1)?.to_owned();
Some((id, item)) Some((id, item))
}).for_each(|(id, item)| { }).for_each(|(id, item)| {
out.push_str(&format!("({}, \"{}\"),\n", id, item)) out.push_str(&format!(" ({}, \"{}\"),\n", id, item))
}); });
out.push_str("].iter().cloned().collect()\n"); out.push_str(" ].iter().cloned().collect()};\n");
out.push_str("};\n");
out.push_str("}"); out.push_str("}");
out out
} }
fn save_file(file_name: &str, content: &str) { fn save_file(file_name: &str, content: &str) {
let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&"src/game_messages").join(file_name);
let dest_path = Path::new(&out_dir).join(file_name);
let mut f = File::create(&dest_path).unwrap(); let mut f = File::create(&dest_path).unwrap();
f.write_all(content.as_bytes()).unwrap(); f.write_all(content.as_bytes()).unwrap();
} }
+53 -53
View File
@@ -11,7 +11,7 @@ use packet_sniffer::UdpPacket;
use photon_decode; use photon_decode;
use photon_decode::Photon; use photon_decode::Photon;
use crate::game_protocol; use crate::game_messages;
use crate::meter; use crate::meter;
pub use meter::GameStats; pub use meter::GameStats;
pub use meter::LastFightStats; pub use meter::LastFightStats;
@@ -23,7 +23,7 @@ pub use meter::PlayerStatisticsVec;
pub use meter::ZoneStats; pub use meter::ZoneStats;
pub use meter::StatType; pub use meter::StatType;
pub use crate::game_protocol::Items; pub use crate::game_messages::Items;
pub enum InitializationError { pub enum InitializationError {
NetworkInterfaceListMissing, NetworkInterfaceListMissing,
@@ -96,7 +96,7 @@ pub fn initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
let game_messages = photon let game_messages = photon
.decode(&packet.payload) .decode(&packet.payload)
.into_iter() .into_iter()
.filter_map(game_protocol::into_game_message) .filter_map(game_messages::into_game_message)
.collect(); .collect();
register_messages(meter, &game_messages); register_messages(meter, &game_messages);
} }
@@ -110,38 +110,38 @@ pub fn initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
Ok(meter) Ok(meter)
} }
pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_protocol::Message>) { pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_messages::Message>) {
messages messages
.iter() .iter()
.for_each(|message| register_message(meter, &message)); .for_each(|message| register_message(meter, &message));
} }
fn register_message<Events>(events: &mut Events, message: &game_protocol::Message) fn register_message<Events>(events: &mut Events, message: &game_messages::Message)
where where
Events: PlayerEvents, Events: PlayerEvents,
{ {
info!("Found message {:?}", message); info!("Found message {:?}", message);
match message { match message {
game_protocol::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()), game_messages::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()),
game_protocol::Message::NewCharacter(msg) => { game_messages::Message::NewCharacter(msg) => {
events.register_player(&msg.character_name, msg.source); events.register_player(&msg.character_name, msg.source);
events.register_item_update(msg.source, &msg.items); events.register_item_update(msg.source, &msg.items);
}, },
game_protocol::Message::CharacterEquipmentChanged(msg) => { game_messages::Message::CharacterEquipmentChanged(msg) => {
events.register_item_update(msg.source, &msg.items); events.register_item_update(msg.source, &msg.items);
}, },
game_protocol::Message::Join(msg) => { game_messages::Message::Join(msg) => {
events.register_main_player(&msg.character_name, msg.source) events.register_main_player(&msg.character_name, msg.source)
} }
game_protocol::Message::HealthUpdate(msg) => events game_messages::Message::HealthUpdate(msg) => events
.register_damage_dealt(msg.target, msg.value) .register_damage_dealt(msg.target, msg.value)
.unwrap_or(()), .unwrap_or(()),
game_protocol::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate { game_messages::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate {
Some(_) => events.register_combat_leave(msg.source).unwrap_or(()), Some(_) => events.register_combat_leave(msg.source).unwrap_or(()),
None => events.register_combat_enter(msg.source).unwrap_or(()), None => events.register_combat_enter(msg.source).unwrap_or(()),
}, },
game_protocol::Message::KnockedDown(msg) => events.register_combat_leave(msg.source).unwrap_or(()), game_messages::Message::KnockedDown(msg) => events.register_combat_leave(msg.source).unwrap_or(()),
game_protocol::Message::UpdateFame(msg) => events game_messages::Message::UpdateFame(msg) => events
.register_fame_gain(msg.source, msg.fame as f32 / 10000.0) .register_fame_gain(msg.source, msg.fame as f32 / 10000.0)
.unwrap_or(()), .unwrap_or(()),
} }
@@ -151,9 +151,9 @@ where
mod tests { mod tests {
use super::*; use super::*;
use game_protocol::message; use game_messages::messages;
use game_protocol::Items; use game_messages::Items;
use game_protocol::Message; use game_messages::Message;
mod helpers { mod helpers {
use super::*; use super::*;
@@ -185,7 +185,7 @@ mod tests {
fn disabled(source: usize) -> Self; fn disabled(source: usize) -> Self;
} }
impl NamedTesting for message::NewCharacter { impl NamedTesting for messages::NewCharacter {
fn new_named(name: &str, source: usize) -> Self { fn new_named(name: &str, source: usize) -> Self {
Self { Self {
source: source, source: source,
@@ -194,12 +194,12 @@ mod tests {
max_health: 10.0, max_health: 10.0,
energy: 1.0, energy: 1.0,
max_energy: 1.0, max_energy: 1.0,
items: Items::from(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), items: Items::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
} }
} }
} }
impl NamedTesting for message::Join { impl NamedTesting for messages::Join {
fn new_named(name: &str, source: usize) -> Self { fn new_named(name: &str, source: usize) -> Self {
Self { Self {
source: source, source: source,
@@ -212,25 +212,25 @@ mod tests {
} }
} }
impl Testing for message::NewCharacter { impl Testing for messages::NewCharacter {
fn new(source: usize) -> Self { fn new(source: usize) -> Self {
message::NewCharacter::new_named("CH1", source) messages::NewCharacter::new_named("CH1", source)
} }
} }
impl Testing for message::Join { impl Testing for messages::Join {
fn new(source: usize) -> Self { fn new(source: usize) -> Self {
message::Join::new_named("MAIN_CH1", source) messages::Join::new_named("MAIN_CH1", source)
} }
} }
impl Testing for message::Leave { impl Testing for messages::Leave {
fn new(source: usize) -> Self { fn new(source: usize) -> Self {
Self { source: source } Self { source: source }
} }
} }
impl Testing for message::HealthUpdate { impl Testing for messages::HealthUpdate {
fn new(source: usize) -> Self { fn new(source: usize) -> Self {
Self { Self {
source: 200, source: 200,
@@ -240,7 +240,7 @@ mod tests {
} }
} }
impl Testing for message::UpdateFame { impl Testing for messages::UpdateFame {
fn new(source: usize) -> Self { fn new(source: usize) -> Self {
Self { Self {
source: source, source: source,
@@ -249,7 +249,7 @@ mod tests {
} }
} }
impl SwitchableTesting for message::RegenerationHealthChanged { impl SwitchableTesting for messages::RegenerationHealthChanged {
fn enabled(source: usize) -> Self { fn enabled(source: usize) -> Self {
Self { Self {
source: source, source: source,
@@ -280,7 +280,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)), &Message::NewCharacter(messages::NewCharacter::new(1)),
); );
assert_eq!(stats(&meter, StatType::Zone).len(), 1); assert_eq!(stats(&meter, StatType::Zone).len(), 1);
} }
@@ -290,7 +290,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)), &Message::NewCharacter(messages::NewCharacter::new(1)),
); );
assert_eq!(stats(&meter, StatType::Zone).len(), 1); assert_eq!(stats(&meter, StatType::Zone).len(), 1);
@@ -310,7 +310,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)), &Message::NewCharacter(messages::NewCharacter::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
@@ -318,21 +318,21 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)), &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0); assert_eq!(zone_stats[0].damage, 0.0);
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)), &Message::HealthUpdate(messages::HealthUpdate::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0); assert_eq!(zone_stats[0].damage, 10.0);
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)), &Message::HealthUpdate(messages::HealthUpdate::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 20.0); assert_eq!(zone_stats[0].damage, 20.0);
@@ -343,7 +343,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)), &Message::NewCharacter(messages::NewCharacter::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
@@ -352,11 +352,11 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)), &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
); );
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)), &Message::HealthUpdate(messages::HealthUpdate::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0); assert_eq!(zone_stats[0].damage, 10.0);
@@ -367,7 +367,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)), &Message::NewCharacter(messages::NewCharacter::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
@@ -376,11 +376,11 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)), &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
); );
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)), &Message::HealthUpdate(messages::HealthUpdate::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0); assert_eq!(zone_stats[0].damage, 10.0);
@@ -395,7 +395,7 @@ mod tests {
let mut meter = helpers::init_(); let mut meter = helpers::init_();
register_message( register_message(
&mut meter, &mut meter,
&Message::Join(message::Join::new(1)), &Message::Join(messages::Join::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
@@ -404,19 +404,19 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)), &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
); );
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)), &Message::HealthUpdate(messages::HealthUpdate::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0); assert_eq!(zone_stats[0].damage, 10.0);
register_message(&mut meter, &Message::Leave(message::Leave::new(1))); register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
register_message( register_message(
&mut meter, &mut meter,
&Message::Join(message::Join::new(2)), &Message::Join(messages::Join::new(2)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
@@ -424,11 +424,11 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(2)), &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(2)),
); );
register_message( register_message(
&mut meter, &mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(2)), &Message::HealthUpdate(messages::HealthUpdate::new(2)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0); assert_eq!(zone_stats[0].damage, 10.0);
@@ -438,7 +438,7 @@ mod tests {
($meter:expr, $name:expr, $id:expr) => { ($meter:expr, $name:expr, $id:expr) => {
register_message( register_message(
&mut $meter, &mut $meter,
&Message::Join(message::Join::new_named($name, $id)), &Message::Join(messages::Join::new_named($name, $id)),
); );
}; };
} }
@@ -447,7 +447,7 @@ mod tests {
($meter:expr, $name:expr, $id:expr) => { ($meter:expr, $name:expr, $id:expr) => {
register_message( register_message(
&mut $meter, &mut $meter,
&Message::NewCharacter(message::NewCharacter::new_named($name, $id)), &Message::NewCharacter(messages::NewCharacter::new_named($name, $id)),
); );
}; };
} }
@@ -456,13 +456,13 @@ mod tests {
($meter:expr, $id:expr) => { ($meter:expr, $id:expr) => {
register_message( register_message(
&mut $meter, &mut $meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled( &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(
$id, $id,
)), )),
); );
register_message( register_message(
&mut $meter, &mut $meter,
&Message::HealthUpdate(message::HealthUpdate::new($id)), &Message::HealthUpdate(messages::HealthUpdate::new($id)),
); );
}; };
} }
@@ -471,7 +471,7 @@ mod tests {
($meter:expr, $id:expr) => { ($meter:expr, $id:expr) => {
register_message( register_message(
&mut $meter, &mut $meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::enabled( &Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::enabled(
$id, $id,
)), )),
); );
@@ -492,7 +492,7 @@ mod tests {
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap(); let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0); assert_eq!(player_stats.damage, 0.0);
register_message(&mut meter, &Message::Leave(message::Leave::new(1))); register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none()); assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
} }
@@ -630,7 +630,7 @@ mod tests {
register_message( register_message(
&mut meter, &mut meter,
&Message::UpdateFame(message::UpdateFame::new(1)), &Message::UpdateFame(messages::UpdateFame::new(1)),
); );
let zone_stats = stats(&meter, StatType::Zone); let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap(); let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
File diff suppressed because it is too large Load Diff
+340
View File
@@ -0,0 +1,340 @@
use log::*;
use crate::game_messages::Items;
use photon_decode::Parameters;
use photon_decode::Value;
macro_rules! decode_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),
Value::Byte(v) => Some(*v as usize),
_ => {
error!("Failed to decode {}", $name);
None
}
}
} else {
error!("Index {} not found in {}", $index, $name);
None
}
};
}
macro_rules! decode_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 decode {}", $name);
None
}
}
} else {
None
}
};
}
#[allow(unused_macros)]
macro_rules! decode_string_vec {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::Array(arr) => {
let mut ret = vec![];
for v in arr {
if let Value::String(s) = v {
ret.push(s.clone());
}
}
Some(ret)
}
_ => {
error!("Failed to decode {}", $name);
None
}
}
} else {
None
}
};
}
macro_rules! decode_number_vec {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::Array(arr) => {
let mut ret = vec![];
for v in arr {
match v {
Value::Short(v) => {
ret.push(*v as u32);
},
Value::Byte(v) => {
ret.push(*v as u32);
},
_ => {}
}
}
Some(ret)
},
Value::ByteArray(v) => {
Some(v.iter().map(|b| *b as u32).collect::<Vec<u32>>())
},
_ => {
error!("Failed to decode {}", $name);
None
}
}
} else {
None
}
};
}
macro_rules! decode_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 decode {}", $name);
None
}
}
} else {
None
}
};
}
#[derive(Debug, Default)]
pub struct Leave {
pub source: usize,
}
impl Leave {
pub fn parse(val: Parameters) -> Option<Message> {
info!("Leave parameters: {:?}", val);
let source = decode_number!(val, 0, "Leave::source")?;
Some(Message::Leave(Leave { source, }))
}
}
#[derive(Debug, Default)]
pub struct HealthUpdate {
pub source: usize,
pub target: usize,
pub value: f32,
}
impl HealthUpdate {
pub fn parse(val: Parameters) -> Option<Message> {
info!("HealthUpdate parameters: {:?}", val);
let source = decode_number!(val, 0, "HealthUpdate::source")?;
let target = decode_number!(val, 6, "HealthUpdate::target")?;
let value = decode_float!(val, 2, "HealthUpdate::value")?;
Some(Message::HealthUpdate(HealthUpdate { source, target, value, }))
}
}
#[derive(Debug, Default)]
pub struct RegenerationHealthChanged {
pub source: usize,
pub health: f32,
pub max_health: f32,
pub regeneration_rate: Option<f32>,
}
impl RegenerationHealthChanged {
pub fn parse(val: Parameters) -> Option<Message> {
info!("RegenerationHealthChanged parameters: {:?}", val);
let source = decode_number!(val, 0, "RegenerationHealthChanged::source")?;
let health = decode_float!(val, 2, "RegenerationHealthChanged::health")?;
let max_health = decode_float!(val, 3, "RegenerationHealthChanged::max_health")?;
let regeneration_rate = decode_float!(val, 4, "RegenerationHealthChanged::regeneration_rate");
Some(Message::RegenerationHealthChanged(RegenerationHealthChanged { source, health, max_health, regeneration_rate, }))
}
}
#[derive(Debug, Default)]
pub struct KnockedDown {
pub source: usize,
pub target: usize,
pub target_name: String,
}
impl KnockedDown {
pub fn parse(val: Parameters) -> Option<Message> {
info!("KnockedDown parameters: {:?}", val);
let source = decode_number!(val, 0, "KnockedDown::source")?;
let target = decode_number!(val, 3, "KnockedDown::target")?;
let target_name = decode_string!(val, 4, "KnockedDown::target_name")?;
Some(Message::KnockedDown(KnockedDown { source, target, target_name, }))
}
}
#[derive(Debug, Default)]
pub struct NewCharacter {
pub source: usize,
pub character_name: String,
pub health: f32,
pub max_health: f32,
pub energy: f32,
pub max_energy: f32,
pub items: Items,
}
impl NewCharacter {
pub fn parse(val: Parameters) -> Option<Message> {
info!("NewCharacter parameters: {:?}", val);
let source = decode_number!(val, 0, "NewCharacter::source")?;
let character_name = decode_string!(val, 1, "NewCharacter::character_name")?;
let health = decode_float!(val, 18, "NewCharacter::health")?;
let max_health = decode_float!(val, 19, "NewCharacter::max_health")?;
let energy = decode_float!(val, 22, "NewCharacter::energy")?;
let max_energy = decode_float!(val, 23, "NewCharacter::max_energy")?;
let item_array = decode_number_vec!(val, 33, "NewCharacter::item_array")?;
let items = item_array.into();
Some(Message::NewCharacter(NewCharacter { source, character_name, health, max_health, energy, max_energy, items, }))
}
}
#[derive(Debug, Default)]
pub struct UpdateFame {
pub source: usize,
pub fame: usize,
}
impl UpdateFame {
pub fn parse(val: Parameters) -> Option<Message> {
info!("UpdateFame parameters: {:?}", val);
let source = decode_number!(val, 0, "UpdateFame::source")?;
let fame = decode_number!(val, 2, "UpdateFame::fame")?;
Some(Message::UpdateFame(UpdateFame { source, fame, }))
}
}
#[derive(Debug, Default)]
pub struct CharacterEquipmentChanged {
pub source: usize,
pub items: Items,
}
impl CharacterEquipmentChanged {
pub fn parse(val: Parameters) -> Option<Message> {
info!("CharacterEquipmentChanged parameters: {:?}", val);
let source = decode_number!(val, 0, "CharacterEquipmentChanged::source")?;
let item_array = decode_number_vec!(val, 2, "CharacterEquipmentChanged::item_array")?;
let items = item_array.into();
Some(Message::CharacterEquipmentChanged(CharacterEquipmentChanged { source, items, }))
}
}
#[derive(Debug, Default)]
pub struct Join {
pub source: usize,
pub character_name: String,
pub health: f32,
pub max_health: f32,
pub energy: f32,
pub max_energy: f32,
}
impl Join {
pub fn parse(val: Parameters) -> Option<Message> {
info!("Join parameters: {:?}", val);
let source = decode_number!(val, 0, "Join::source")?;
let character_name = decode_string!(val, 2, "Join::character_name")?;
let health = decode_float!(val, 11, "Join::health")?;
let max_health = decode_float!(val, 12, "Join::max_health")?;
let energy = decode_float!(val, 15, "Join::energy")?;
let max_energy = decode_float!(val, 16, "Join::max_energy")?;
Some(Message::Join(Join { source, character_name, health, max_health, energy, max_energy, }))
}
}
#[derive(Debug)]
pub enum Message {
Leave(Leave),
HealthUpdate(HealthUpdate),
RegenerationHealthChanged(RegenerationHealthChanged),
KnockedDown(KnockedDown),
NewCharacter(NewCharacter),
UpdateFame(UpdateFame),
CharacterEquipmentChanged(CharacterEquipmentChanged),
Join(Join),
}
pub fn into_game_message(photon_message: photon_decode::Message) -> Option<Message> {
debug!("Raw photon : {:?}", photon_message);
match photon_message {
photon_decode::Message::Event(photon_decode::EventData{
code: 1,
parameters
}) => {
match parameters.get(&252u8) {
Some(photon_decode::Value::Short(1)) => Leave::parse(parameters),
Some(photon_decode::Value::Short(6)) => HealthUpdate::parse(parameters),
Some(photon_decode::Value::Short(80)) => RegenerationHealthChanged::parse(parameters),
Some(photon_decode::Value::Short(150)) => KnockedDown::parse(parameters),
Some(photon_decode::Value::Short(24)) => NewCharacter::parse(parameters),
Some(photon_decode::Value::Short(72)) => UpdateFame::parse(parameters),
Some(photon_decode::Value::Short(79)) => CharacterEquipmentChanged::parse(parameters),
_ => None
}
},
photon_decode::Message::Request(photon_decode::OperationRequest{
code: 1,
parameters
}) => {
match parameters.get(&253u8) {
_ => None
}
},
photon_decode::Message::Response(photon_decode::OperationResponse{
code: 1,
parameters,
return_code: _,
debug_message: _
}) => {
match parameters.get(&253u8) {
Some(photon_decode::Value::Short(2)) => Join::parse(parameters),
_ => None
}
},
_ => None
}
}
@@ -1,14 +1,20 @@
include!(concat!(env!("OUT_DIR"), "/itemdb.rs")); //! Translates photon packets into game messages
pub mod message{ //! Generated messages based on assets/messages.json
include!(concat!(env!("OUT_DIR"), "/messages.rs")); //! See build.rs
} pub mod messages;
/// generated from assets/item_ids.txt
/// See build.rs
mod itemdb;
use itemdb::ITEMDB;
pub use message::Message; use std::convert::From;
pub use message::into_game_message;
pub use messages::Message;
pub use messages::into_game_message;
/// Player inventory items
#[derive(Debug, Clone, PartialEq, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct Items { pub struct Items {
pub weapon: Option<String>, pub weapon: Option<String>,
@@ -23,8 +29,8 @@ pub struct Items {
pub food: Option<String>, pub food: Option<String>,
} }
impl Items { impl From<std::vec::Vec<u32>> for Items {
pub fn from(item_array: &[u32]) -> Self { fn from(item_array: std::vec::Vec<u32>) -> Self {
macro_rules! extract { macro_rules! extract {
($id:expr) => { ($id:expr) => {
item_array item_array
+1 -1
View File
@@ -4,7 +4,7 @@ extern crate cpython;
#[macro_use] #[macro_use]
extern crate lazy_static; extern crate lazy_static;
pub mod game_protocol; pub mod game_messages;
mod meter; mod meter;
mod core; mod core;
+3 -3
View File
@@ -12,7 +12,7 @@ mod session;
use player::Player; use player::Player;
pub use super::game_protocol; pub use super::game_messages;
pub use traits::*; pub use traits::*;
pub use types::*; pub use types::*;
@@ -26,7 +26,7 @@ pub struct Meter {
zone_session: Option<Session>, zone_session: Option<Session>,
last_fight_session: Session, last_fight_session: Session,
main_player_id: Option<usize>, main_player_id: Option<usize>,
unconsumed_items: HashMap<usize, game_protocol::Items>, unconsumed_items: HashMap<usize, game_messages::Items>,
config: MeterConfig, config: MeterConfig,
} }
@@ -141,7 +141,7 @@ impl PlayerEvents for Meter {
fn register_item_update( fn register_item_update(
&mut self, &mut self,
player_id: usize, player_id: usize,
items: &game_protocol::Items, items: &game_messages::Items,
) -> Option<()> { ) -> Option<()> {
let mut consumed = false; let mut consumed = false;
for player in self.get_item_carriers_in_zone(player_id).unwrap_or(vec![]) { for player in self.get_item_carriers_in_zone(player_id).unwrap_or(vec![]) {
+1 -1
View File
@@ -3,7 +3,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))] #[cfg(not(test))]
use std::time::Instant; use std::time::Instant;
use super::game_protocol::Items; use super::game_messages::Items;
use super::traits::CombatState; use super::traits::CombatState;
use super::traits::DamageDealer; use super::traits::DamageDealer;
+1 -1
View File
@@ -4,7 +4,7 @@ use fake_clock::FakeClock as Instant;
use std::time::Instant; use std::time::Instant;
use super::types::PlayerStatisticsVec; use super::types::PlayerStatisticsVec;
use super::game_protocol::Items; use super::game_messages::Items;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum CombatState { pub enum CombatState {
+1 -1
View File
@@ -5,7 +5,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))] #[cfg(not(test))]
use std::time::Instant; use std::time::Instant;
use super::game_protocol::Items; use super::game_messages::Items;
use super::traits::DamageStats; use super::traits::DamageStats;
use super::traits::FameStats; use super::traits::FameStats;