From 9cd00e236f9561aec2e38f0d20e7cc3ff8583255 Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Fri, 27 Sep 2019 22:35:14 +0200 Subject: [PATCH] + skip_non_party_members --- gui/src/config.py | 19 +- gui/src/meter.py | 5 +- src/core.rs | 722 +++++++++++++++++++++++++++++++++++ src/game_protocol/message.rs | 78 +++- src/lib.rs | 651 +------------------------------ src/meter/mod.rs | 147 ++++--- src/meter/traits.rs | 14 +- src/meter/types.rs | 106 ++++- 8 files changed, 1026 insertions(+), 716 deletions(-) create mode 100644 src/core.rs diff --git a/gui/src/config.py b/gui/src/config.py index 4460fe5..36f694d 100644 --- a/gui/src/config.py +++ b/gui/src/config.py @@ -1,7 +1,8 @@ import os +import sys import toml -CFG_VERSION = '0.1' +CFG_VERSION = '0.2' default = """ [window] @@ -10,21 +11,25 @@ height = 200 font-size = '10px' opacity = 0.5 +[app] +skip_non_party_players = true + [config] # do not change version = '%s' """ % (CFG_VERSION) -_script_path = None - - -def set_script_path(path): - global _script_path - _script_path = path +_script_path = sys.argv[0] # pyinstaller creates tmpdir for python files, thus this is the way to get executable path +_config = None def config(): global _script_path + global _config + + if _config: + return _config + conf_file = os.path.join(os.path.dirname( _script_path), 'albion-online-stats.cfg') diff --git a/gui/src/meter.py b/gui/src/meter.py index d445150..0f3639b 100644 --- a/gui/src/meter.py +++ b/gui/src/meter.py @@ -6,9 +6,6 @@ from PySide2.QtWidgets import QMessageBox import libmeter -from config import set_script_path -set_script_path(sys.argv[0]) # pyinstaller creates tmpdir for python files, thus this is the way to get executable path - from config import config from main import MainWidget from engine import initialize @@ -42,7 +39,7 @@ if __name__ == "__main__": current_version, latest_version = (current_version(), latest_version()) - if current_version != latest_version: + if latest_version and current_version != latest_version: msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowTitle("Update available!") diff --git a/src/core.rs b/src/core.rs new file mode 100644 index 0000000..95932d8 --- /dev/null +++ b/src/core.rs @@ -0,0 +1,722 @@ +use std::fs::File; +use std::sync::mpsc::{channel, Receiver, Sender}; +use std::sync::Mutex; +use std::thread; + +use cpython::PyList; +use cpython::PyObject; +use cpython::PyResult; +use cpython::Python; +use cpython::ToPyObject; + +use log::*; +use simplelog::*; + +use packet_sniffer::UdpPacket; + +use crate::game_protocol; +use crate::meter; +use meter::PartyEvents; +use meter::PlayerEvents; +use meter::ZoneStats; + +lazy_static! { + static ref METER: Mutex = Mutex::new(meter::Meter::new()); +} + +pub fn get_zone_session(py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + meter.get_zone_session().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ) +} + +pub fn get_overall_session(py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + meter.get_overall_session().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ) +} + +pub fn get_last_fight_session(py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + meter.get_last_fight_session().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ) +} + +pub fn new_zone_session(_py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + + meter.new_zone_session(); + + Ok(0) +} + +pub fn reset_sessions(_py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + + meter.reset(); + + Ok(0) +} + +pub fn new_last_fight_session(_py: Python) -> PyResult { + let meter = &mut METER.lock().unwrap(); + + meter.new_last_fight_session(); + + Ok(0) +} + +pub fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult { + CombinedLogger::init(vec![WriteLogger::new( + LevelFilter::Trace, + Config::default(), + File::create("damage-meter.log").unwrap(), + )]) + .unwrap(); + + configure(&mut METER.lock().unwrap(), meter::MeterConfig { + skip_non_party_members, + ..Default::default() + }); + + thread::spawn(move || { + let (tx, rx): (Sender, Receiver) = channel(); + + packet_sniffer::receive(tx); + info!("Listening to network packets..."); + loop { + if let Ok(packet) = rx.recv() { + if packet.destination_port != 5056 && packet.source_port != 5056 { + continue; + } + let meter = &mut METER.lock().unwrap(); + if let Some(messages) = game_protocol::decode(&packet.payload) { + register_messages(meter, &messages); + } + } + } + }); + + Ok(0) +} + +fn configure(meter: &mut meter::Meter, config: meter::MeterConfig) { + meter.configure(config); +} + +fn register_messages(meter: &mut meter::Meter, messages: &Vec) { + messages + .iter() + .for_each(|message| register_message(meter, &message)); +} + +fn register_message(events: &mut meter::Meter, message: &game_protocol::Message) { + debug!("Found message {:?}", message); + match message { + game_protocol::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()), + game_protocol::Message::NewCharacter(msg) => { + events.register_player(&msg.character_name, msg.source) + } + game_protocol::Message::CharacterStats(msg) => { + events.register_main_player(&msg.character_name, msg.source) + } + game_protocol::Message::HealthUpdate(msg) => events + .register_damage_dealt(msg.target, msg.value) + .unwrap_or(()), + game_protocol::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate { + Some(_) => events.register_combat_leave(msg.source).unwrap_or(()), + None => events.register_combat_enter(msg.source).unwrap_or(()), + }, + game_protocol::Message::Died(msg) => events.register_combat_leave(msg.source).unwrap_or(()), + game_protocol::Message::PartyNew(msg) => events + .register_new_party(&msg.players, msg.source) + .unwrap_or(()), + game_protocol::Message::PartyJoin(msg) => { + events.register_new_member(&msg.target_name).unwrap_or(()) + } + game_protocol::Message::PartyDisbanded(_) => { + events.register_party_disbanded().unwrap_or(()) + } + _ => {} + } +} + +#[cfg(test)] +mod tests { + use super::*; + use cpython::{PyClone, PyDict, PyFloat, PyUnicode}; + + use game_protocol::message; + use game_protocol::Message; + + mod helpers { + use super::*; + + pub fn init() -> cpython::GILGuard { + let meter = &mut METER.lock().unwrap(); + meter.reset(); + + super::configure(meter, Default::default()); + + Python::acquire_gil() + } + + pub fn register(message: Message) { + let meter = &mut METER.lock().unwrap(); + r(meter, &message); + } + + fn r(meter: &mut meter::Meter, message: &game_protocol::Message) { + register_message(meter, &message); + } + + pub fn configure(cfg: meter::MeterConfig) { + let meter = &mut METER.lock().unwrap(); + super::configure(meter, cfg); + } + + pub fn get_damage_dealer_in_zone_by_index(py: Python, index: usize) -> PyDict { + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, index); + let player = stat.cast_as::(py).unwrap().clone_ref(py); + player + } + + pub fn get_damage_dealer_in_zone_by_name(py: Python, name: &str) -> Option { + let zone_session_len = get_zone_session(py).unwrap().len(py); + + for idx in 0..zone_session_len { + let player = get_damage_dealer_in_zone_by_index(py, idx); + if get_string(py, &player, "player") == name { + return Some(player); + } + } + None + } + + pub fn get_player_overall_index(py: Python, index: usize) -> PyDict { + let zone_session = get_overall_session(py).unwrap(); + let stat = zone_session.get_item(py, index); + let player = stat.cast_as::(py).unwrap().clone_ref(py); + player + } + + pub fn get_player_overall_by_name(py: Python, name: &str) -> Option { + let zone_session_len = get_overall_session(py).unwrap().len(py); + + for idx in 0..zone_session_len { + let player = get_player_overall_index(py, idx); + if get_string(py, &player, "player") == name { + return Some(player); + } + } + None + } + + pub fn get_player_last_fight_index(py: Python, index: usize) -> PyDict { + let zone_session = get_last_fight_session(py).unwrap(); + let stat = zone_session.get_item(py, index); + let player = stat.cast_as::(py).unwrap().clone_ref(py); + player + } + + pub fn get_player_last_fight_by_name(py: Python, name: &str) -> Option { + let zone_session_len = get_last_fight_session(py).unwrap().len(py); + + for idx in 0..zone_session_len { + let player = get_player_last_fight_index(py, idx); + if get_string(py, &player, "player") == name { + return Some(player); + } + } + None + } + + pub fn get_string(py: Python, stats: &PyDict, key: &str) -> String { + stats + .get_item(py, key) + .unwrap() + .cast_as::(py) + .unwrap() + .to_string_lossy(py) + .to_string() + } + + pub fn get_float(py: Python, stats: &PyDict, key: &str) -> f64 { + stats + .get_item(py, key) + .unwrap() + .cast_as::(py) + .unwrap() + .value(py) + } + } + + trait Testing { + fn new(source: usize) -> Self; + } + + trait NamedTesting { + fn new_named(name: &str, source: usize) -> Self; + } + + trait ListNamedTesting { + fn new_list_of_named(names: &[&str], source: usize) -> Self; + } + + trait SwitchableTesting { + fn enabled(source: usize) -> Self; + fn disabled(source: usize) -> Self; + } + + impl NamedTesting for message::NewCharacter { + fn new_named(name: &str, source: usize) -> Self { + Self { + source: source, + character_name: name.to_owned(), + health: 10.0, + max_health: 10.0, + energy: 1.0, + max_energy: 1.0, + } + } + } + + impl NamedTesting for message::CharacterStats { + fn new_named(name: &str, source: usize) -> Self { + Self { + source: source, + character_name: name.to_owned(), + health: 10.0, + max_health: 10.0, + energy: 1.0, + max_energy: 1.0, + } + } + } + + impl Testing for message::NewCharacter { + fn new(source: usize) -> Self { + message::NewCharacter::new_named("CH1", source) + } + } + + impl Testing for message::CharacterStats { + fn new(source: usize) -> Self { + message::CharacterStats::new_named("MAIN_CH1", source) + } + } + + impl Testing for message::Leave { + fn new(source: usize) -> Self { + Self { source: source } + } + } + + impl Testing for message::HealthUpdate { + fn new(source: usize) -> Self { + Self { + source: 200, + target: source, + value: -10.0, + } + } + } + + impl SwitchableTesting for message::RegenerationHealthChanged { + fn enabled(source: usize) -> Self { + Self { + source: source, + health: 10.0, + max_health: 10.0, + regeneration_rate: Some(1.0), + } + } + + fn disabled(source: usize) -> Self { + Self { + source: source, + health: 10.0, + max_health: 10.0, + regeneration_rate: None, + } + } + } + + impl ListNamedTesting for message::PartyNew { + fn new_list_of_named(names: &[&str], source: usize) -> Self { + Self { + source: source, + players: names.iter().map(ToString::to_string).collect(), + } + } + } + + impl NamedTesting for message::PartyJoin { + fn new_named(name: &str, source: usize) -> Self { + Self { + target_name: name.to_string(), + source, + } + } + } + + impl Testing for message::PartyDisbanded { + fn new(source: usize) -> Self { + Self { source } + } + } + + #[test] + fn test_empty_session() { + let guard = helpers::init(); + let py = guard.python(); + + assert_eq!(get_zone_session(py).unwrap().len(py), 0); + } + + #[test] + fn test_new_player_appears() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); + + let zone_session = get_zone_session(py).unwrap(); + assert_eq!(zone_session.len(py), 1); + } + + #[test] + fn test_new_player_stats() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(stats.len(py), 4); + assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + assert_eq!(helpers::get_float(py, &stats, "time_in_combat"), 0.0); + assert_eq!(helpers::get_float(py, &stats, "dps"), 0.0); + } + + #[test] + fn test_damage_aggregation() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0); + } + + #[test] + fn test_new_player_damage() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + } + + #[test] + fn test_new_player_damage_reset() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + new_zone_session(py).unwrap(); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + } + + #[test] + fn test_zone_detection() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new(1))); + + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + helpers::register(Message::Leave(message::Leave::new(1))); + helpers::register(Message::CharacterStats(message::CharacterStats::new(2))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(2), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2))); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + } + + #[test] + fn test_two_players_in_the_zone() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "MAIN_CH1", 1, + ))); + let stats = helpers::get_damage_dealer_in_zone_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::NewCharacter(message::NewCharacter::new_named( + "CH1", 2, + ))); + let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1").unwrap(); + assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::Leave(message::Leave::new(1))); + let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1"); + assert!(stats.is_none()); + } + + #[test] + fn test_overall_damage() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "MAIN_CH1", 1, + ))); + let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + helpers::register(Message::Leave(message::Leave::new(1))); + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "MAIN_CH1", 1, + ))); + let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0); + } + + #[test] + fn test_last_fight_damage() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "MAIN_CH1", 1, + ))); + let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); + assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap(); + assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(1), + )); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + } + + #[test] + fn test_last_fight_management() { + // session should be started when first player attacks + // damage should be 0 when all players were out of combat and some player attacks + + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "1", 1, + ))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + + assert!(helpers::get_player_last_fight_by_name(py, "1").is_some()); + + helpers::register(Message::NewCharacter(message::NewCharacter::new_named( + "2", 2, + ))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(2), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(2), + )); + + helpers::register(Message::NewCharacter(message::NewCharacter::new_named( + "3", 3, + ))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(3), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(3))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(3), + )); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(1), + )); + + macro_rules! assert_named_player_dmg { + ($id:expr, $dmg:expr) => { + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, $id).unwrap(), + "damage" + ), + $dmg + ); + }; + } + + assert_named_player_dmg!("1", 10.0); + assert_named_player_dmg!("2", 10.0); + assert_named_player_dmg!("3", 10.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(2), + )); + + assert_named_player_dmg!("1", 10.0); + assert_named_player_dmg!("2", 10.0); + assert_named_player_dmg!("3", 10.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(3), + )); + assert_named_player_dmg!("1", 10.0); + assert_named_player_dmg!("2", 10.0); + assert_named_player_dmg!("3", 10.0); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(1), + )); + helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); + assert_named_player_dmg!("1", 10.0); + assert_named_player_dmg!("2", 0.0); + assert_named_player_dmg!("3", 0.0); + } + + #[test] + fn test_party_member_filter() { + let guard = helpers::init(); + let py = guard.python(); + + helpers::configure(meter::MeterConfig { + skip_non_party_members: true, + ..Default::default() + }); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "main_player", 1, + ))); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some()); + + helpers::register(Message::NewCharacter(message::NewCharacter::new_named( + "other_player", 2, + ))); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some()); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_none()); + + helpers::register(Message::PartyNew(message::PartyNew::new_list_of_named( + &["main_player", "other_player"], + 1, + ))); + + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some()); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_some()); + + helpers::register(Message::NewCharacter(message::NewCharacter::new_named( + "yet_another_other_player", 2, + ))); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none()); + + helpers::register(Message::PartyJoin(message::PartyJoin::new_named(&"yet_another_other_player", 1))); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_some()); + + helpers::register(Message::PartyDisbanded(message::PartyDisbanded::new(1))); + + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some()); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_none()); + assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none()); + } +} diff --git a/src/game_protocol/message.rs b/src/game_protocol/message.rs index d8136a4..128dc77 100644 --- a/src/game_protocol/message.rs +++ b/src/game_protocol/message.rs @@ -39,6 +39,32 @@ macro_rules! deserialize_string { }; } +macro_rules! deserialize_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 deserialize {}", $name); + None + } + } + } else { + None + } + }; +} + + macro_rules! deserialize_float { ($val:expr, $index:expr, $name:expr) => { if let Some(p) = $val.get(&$index) { @@ -222,6 +248,50 @@ impl Died { } } +#[derive(Debug)] +pub struct PartyNew { + pub source: usize, + pub players: Vec, +} + +impl PartyNew { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 0, "PartyNew::source")?; + let players = deserialize_string_vec!(val, 5, "PartyNew::players")?; + + Some(Message::PartyNew(PartyNew{source, players})) + } +} + +#[derive(Debug)] +pub struct PartyJoin { + pub source: usize, + pub target_name: String +} + +impl PartyJoin { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 0, "PartyJoin::source")?; + let target_name = deserialize_string!(val, 2, "PartyJoin::target_name")?; + + Some(Message::PartyJoin(PartyJoin{source, target_name})) + } +} + +#[derive(Debug)] +pub struct PartyDisbanded { + pub source: usize, +} + +impl PartyDisbanded { + fn encode(val: Parameters) -> Option { + let source = deserialize_number!(val, 1, "PartyDisbanded::source")?; + + Some(Message::PartyDisbanded(PartyDisbanded{source})) + } +} + + #[derive(Debug)] pub enum Message { Leave(Leave), @@ -230,7 +300,10 @@ pub enum Message { HealthUpdate(HealthUpdate), RegenerationHealthChanged(RegenerationHealthChanged), CharacterStats(CharacterStats), - Died(Died) + Died(Died), + PartyNew(PartyNew), + PartyJoin(PartyJoin), + PartyDisbanded(PartyDisbanded) } impl Packet { @@ -242,6 +315,9 @@ impl Packet { 63 => ChatSay::encode(self.parameters), 79 => RegenerationHealthChanged::encode(self.parameters), 149 => Died::encode(self.parameters), + 210 => PartyNew::encode(self.parameters), + 112 => PartyJoin::encode(self.parameters), + 211 => PartyDisbanded::encode(self.parameters), 1001 => CharacterStats::encode(self.parameters), _ => None, } diff --git a/src/lib.rs b/src/lib.rs index 3ac01e3..840c145 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,162 +1,26 @@ #[macro_use] extern crate cpython; + #[macro_use] extern crate lazy_static; -extern crate bytes; -extern crate packet_sniffer; -extern crate photon_protocol; - -use std::fs::File; -use std::sync::mpsc::{channel, Receiver, Sender}; -use std::sync::Mutex; -use std::thread; - -use cpython::{PyDict, PyList, PyObject, PyResult, Python, PythonObject, ToPyObject}; -use log::*; -use simplelog::*; - -use packet_sniffer::UdpPacket; mod game_protocol; mod meter; -use meter::PlayerEvents; -use meter::ZoneStats; +mod core; -lazy_static! { - static ref METER: Mutex = Mutex::new(meter::Meter::new()); -} +use crate::core::get_last_fight_session; +use crate::core::get_overall_session; +use crate::core::get_zone_session; +use crate::core::initialize; +use crate::core::new_last_fight_session; +use crate::core::new_zone_session; +use crate::core::reset_sessions; -impl ToPyObject for meter::PlayerStatistics { - type ObjectType = PyObject; - fn to_py_object(&self, py: Python) -> Self::ObjectType { - let stats = PyDict::new(py); - - stats - .set_item(py, "player", self.player.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "damage", self.damage.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "time_in_combat", self.time_in_combat.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "dps", self.dps.to_py_object(py)) - .unwrap(); - - stats.into_object() - } -} - -fn get_zone_session(py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - meter.get_zone_session().map_or_else( - || Ok(PyList::new(py, Vec::::new().as_slice())), - |v| { Ok(v.into_py_object(py)) } - ) -} - -fn get_overall_session(py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - meter.get_overall_session().map_or_else( - || Ok(PyList::new(py, Vec::::new().as_slice())), - |v| { Ok(v.into_py_object(py)) } - ) -} - -fn get_last_fight_session(py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - meter.get_last_fight_session().map_or_else( - || Ok(PyList::new(py, Vec::::new().as_slice())), - |v| { Ok(v.into_py_object(py)) } - ) -} - -fn new_zone_session(_py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - meter.new_zone_session(); - - Ok(0) -} - -fn reset_sessions(_py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - meter.reset(); - - Ok(0) -} - -fn new_last_fight_session(_py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - meter.new_last_fight_session(); - - Ok(0) -} - -fn initialize(_py: Python) -> PyResult { - CombinedLogger::init(vec![WriteLogger::new( - LevelFilter::Trace, - Config::default(), - File::create("damage-meter.log").unwrap(), - )]) - .unwrap(); - - thread::spawn(move || { - let (tx, rx): (Sender, Receiver) = channel(); - - packet_sniffer::receive(tx); - info!("Listening to network packets..."); - loop { - if let Ok(packet) = rx.recv() { - if packet.destination_port != 5056 && packet.source_port != 5056 { - continue; - } - let meter = &mut METER.lock().unwrap(); - if let Some(messages) = game_protocol::decode(&packet.payload) { - register_messages(meter, &messages); - } - } - } - }); - - Ok(0) -} - -fn register_messages(meter: &mut meter::Meter, messages: &Vec) { - messages - .iter() - .for_each(|message| register_message(meter, &message)); -} - -fn register_message(events: &mut PlayerEvents, message: &game_protocol::Message) { - debug!("Found message {:?}", message); - match message { - game_protocol::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()), - game_protocol::Message::NewCharacter(msg) => { - events.register_player(&msg.character_name, msg.source) - } - game_protocol::Message::CharacterStats(msg) => { - events.register_main_player(&msg.character_name, msg.source) - } - game_protocol::Message::HealthUpdate(msg) => events - .register_damage_dealt(msg.target, msg.value) - .unwrap_or(()), - game_protocol::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate { - Some(_) => events.register_combat_leave(msg.source).unwrap_or(()), - None => events.register_combat_enter(msg.source).unwrap_or(()), - }, - game_protocol::Message::Died(msg) => events.register_combat_leave(msg.source).unwrap_or(()), - _ => {} - } -} py_module_initializer!(libmeter, initliblibmeter, PyInit_libmeter, |py, m| { m.add(py, "__doc__", "This module is implemented in Rust")?; - m.add(py, "initialize", py_fn!(py, initialize()))?; + m.add(py, "initialize", py_fn!(py, initialize(skip_non_party_members: bool)))?; m.add(py, "new_zone_session", py_fn!(py, new_zone_session()))?; m.add(py, "get_overall_session", py_fn!(py, get_overall_session()))?; m.add( @@ -173,498 +37,3 @@ py_module_initializer!(libmeter, initliblibmeter, PyInit_libmeter, |py, m| { m.add(py, "get_zone_session", py_fn!(py, get_zone_session()))?; Ok(()) }); - -#[cfg(test)] -mod tests { - use super::*; - use cpython::{PyFloat, PyUnicode, PyClone}; - - use game_protocol::message; - use game_protocol::Message; - - mod helpers { - use super::*; - - pub fn init() -> cpython::GILGuard { - let meter = &mut METER.lock().unwrap(); - meter.reset(); - - Python::acquire_gil() - } - - pub fn register(message: Message) { - let meter = &mut METER.lock().unwrap(); - r(meter, &message); - } - - fn r(meter: &mut meter::Meter, message: &game_protocol::Message) { - register_message(meter, &message); - } - - pub fn get_damage_dealer_in_zone_by_index(py: Python, index: usize) -> PyDict { - let zone_session = get_zone_session(py).unwrap(); - let stat = zone_session.get_item(py, index); - let player = stat.cast_as::(py).unwrap().clone_ref(py); - player - } - - pub fn get_damage_dealer_in_zone_by_name(py: Python, name: &str) -> Option { - let zone_session_len = get_zone_session(py).unwrap().len(py); - - for idx in 0..zone_session_len { - let player = get_damage_dealer_in_zone_by_index(py, idx); - if get_string(py, &player, "player") == name { - return Some(player); - } - } - None - } - - pub fn get_player_overall_index(py: Python, index: usize) -> PyDict { - let zone_session = get_overall_session(py).unwrap(); - let stat = zone_session.get_item(py, index); - let player = stat.cast_as::(py).unwrap().clone_ref(py); - player - } - - pub fn get_player_overall_by_name(py: Python, name: &str) -> Option { - let zone_session_len = get_overall_session(py).unwrap().len(py); - - for idx in 0..zone_session_len { - let player = get_player_overall_index(py, idx); - if get_string(py, &player, "player") == name { - return Some(player); - } - } - None - } - - pub fn get_player_last_fight_index(py: Python, index: usize) -> PyDict { - let zone_session = get_last_fight_session(py).unwrap(); - let stat = zone_session.get_item(py, index); - let player = stat.cast_as::(py).unwrap().clone_ref(py); - player - } - - pub fn get_player_last_fight_by_name(py: Python, name: &str) -> Option { - let zone_session_len = get_last_fight_session(py).unwrap().len(py); - - for idx in 0..zone_session_len { - let player = get_player_last_fight_index(py, idx); - if get_string(py, &player, "player") == name { - return Some(player); - } - } - None - } - - pub fn get_string(py: Python, stats: &PyDict, key: &str) -> String { - stats - .get_item(py, key) - .unwrap() - .cast_as::(py) - .unwrap() - .to_string_lossy(py) - .to_string() - } - - pub fn get_float(py: Python, stats: &PyDict, key: &str) -> f64 { - stats - .get_item(py, key) - .unwrap() - .cast_as::(py) - .unwrap() - .value(py) - } - } - - trait Testing { - fn new(source: usize) -> Self; - } - - trait NamedTesting { - fn new_named(name: &str, source: usize) -> Self; - } - - trait SwitchableTesting { - fn enabled(source: usize) -> Self; - fn disabled(source: usize) -> Self; - } - - impl NamedTesting for message::NewCharacter { - fn new_named(name: &str, source: usize) -> Self { - Self { - source: source, - character_name: name.to_owned(), - health: 10.0, - max_health: 10.0, - energy: 1.0, - max_energy: 1.0, - } - } - } - - impl NamedTesting for message::CharacterStats { - fn new_named(name: &str, source: usize) -> Self { - Self { - source: source, - character_name: name.to_owned(), - health: 10.0, - max_health: 10.0, - energy: 1.0, - max_energy: 1.0, - } - } - } - - impl Testing for message::NewCharacter { - fn new(source: usize) -> Self { - message::NewCharacter::new_named("CH1", source) - } - } - - impl Testing for message::CharacterStats { - fn new(source: usize) -> Self { - message::CharacterStats::new_named("MAIN_CH1", source) - } - } - - impl Testing for message::Leave { - fn new(source: usize) -> Self { - Self { source: source } - } - } - - impl Testing for message::HealthUpdate { - fn new(source: usize) -> Self { - Self { - source: 200, - target: source, - value: -10.0, - } - } - } - - impl SwitchableTesting for message::RegenerationHealthChanged { - fn enabled(source: usize) -> Self { - Self { - source: source, - health: 10.0, - max_health: 10.0, - regeneration_rate: Some(1.0), - } - } - - fn disabled(source: usize) -> Self { - Self { - source: source, - health: 10.0, - max_health: 10.0, - regeneration_rate: None, - } - } - } - - #[test] - fn test_empty_session() { - let guard = helpers::init(); - let py = guard.python(); - - assert_eq!(get_zone_session(py).unwrap().len(py), 0); - } - - #[test] - fn test_new_player_appears() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - - let zone_session = get_zone_session(py).unwrap(); - assert_eq!(zone_session.len(py), 1); - } - - #[test] - fn test_new_player_stats() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(stats.len(py), 4); - assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - assert_eq!(helpers::get_float(py, &stats, "time_in_combat"), 0.0); - assert_eq!(helpers::get_float(py, &stats, "dps"), 0.0); - } - - #[test] - fn test_damage_aggregation() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0); - } - - #[test] - fn test_new_player_damage() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - } - - #[test] - fn test_new_player_damage_reset() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - new_zone_session(py).unwrap(); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - } - - #[test] - fn test_zone_detection() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::CharacterStats(message::CharacterStats::new(1))); - - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - helpers::register(Message::Leave(message::Leave::new(1))); - helpers::register(Message::CharacterStats(message::CharacterStats::new(2))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(2), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2))); - let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - } - - #[test] - fn test_two_players_in_the_zone() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "MAIN_CH1", 1, - ))); - let stats = helpers::get_damage_dealer_in_zone_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::NewCharacter(message::NewCharacter::new_named( - "CH1", 2, - ))); - let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1").unwrap(); - assert_eq!(helpers::get_string(py, &stats, "player"), "CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::Leave(message::Leave::new(1))); - let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1"); - assert!(stats.is_none()); - } - - #[test] - fn test_overall_damage() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "MAIN_CH1", 1, - ))); - let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - helpers::register(Message::Leave(message::Leave::new(1))); - helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "MAIN_CH1", 1, - ))); - let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0); - } - - #[test] - fn test_last_fight_damage() { - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "MAIN_CH1", 1, - ))); - let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1"); - assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap(); - assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::enabled(1), - )); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - } - - #[test] - fn test_last_fight_management() { - // session should be started when first player attacks - // damage should be 0 when all players were out of combat and some player attacks - - let guard = helpers::init(); - let py = guard.python(); - - helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "1", 1, - ))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - - assert!(helpers::get_player_last_fight_by_name(py, "1").is_some()); - - helpers::register(Message::NewCharacter(message::NewCharacter::new_named( - "2", 2, - ))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(2), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(2), - )); - - helpers::register(Message::NewCharacter(message::NewCharacter::new_named( - "3", 3, - ))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(3), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(3))); - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(3), - )); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::enabled(1), - )); - - macro_rules! assert_named_player_dmg { - ($id:expr, $dmg:expr) => { - assert_eq!( - helpers::get_float( - py, - &helpers::get_player_last_fight_by_name(py, $id).unwrap(), - "damage" - ), - $dmg - ); - } - } - - assert_named_player_dmg!("1", 10.0); - assert_named_player_dmg!("2", 10.0); - assert_named_player_dmg!("3", 10.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::enabled(2), - )); - - assert_named_player_dmg!("1", 10.0); - assert_named_player_dmg!("2", 10.0); - assert_named_player_dmg!("3", 10.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::enabled(3), - )); - assert_named_player_dmg!("1", 10.0); - assert_named_player_dmg!("2", 10.0); - assert_named_player_dmg!("3", 10.0); - - helpers::register(Message::RegenerationHealthChanged( - message::RegenerationHealthChanged::disabled(1), - )); - helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1))); - assert_named_player_dmg!("1", 10.0); - assert_named_player_dmg!("2", 0.0); - assert_named_player_dmg!("3", 0.0); - } -} diff --git a/src/meter/mod.rs b/src/meter/mod.rs index fe5c2ad..b606368 100644 --- a/src/meter/mod.rs +++ b/src/meter/mod.rs @@ -14,12 +14,9 @@ use player::Player; pub use traits::*; pub use types::*; -#[derive(Hash, Eq, PartialEq, Clone, Debug)] -pub struct PlayerName(String); - #[derive(Debug)] pub struct Session { - players: HashMap, + players: HashMap, } impl Session { @@ -38,16 +35,22 @@ impl Session { Self { players } } - pub fn stats(&self) -> PlayerStatisticsVec { - self.players - .iter() - .map(|(name, player)| PlayerStatistics { - player: name.0.to_owned(), - damage: player.damage(), - time_in_combat: player.time_in_combat(), - dps: player.dps(), - }) - .collect() + pub fn stats(&self, filter: F) -> PlayerStatisticsVec + where + F: Fn(&(&String, &Player)) -> bool, + { + PlayerStatisticsVec::from( + self.players + .iter() + .filter(filter) + .map(|(name, player)| PlayerStatistics { + player: name.to_owned(), + damage: player.damage(), + time_in_combat: player.time_in_combat(), + dps: player.dps(), + }) + .collect(), + ) } pub fn cleanup_players(&mut self) { @@ -56,7 +59,7 @@ impl Session { .iter() .filter(|(_, player)| player.damage() == 0.0) .map(|(name, _)| name.clone()) - .collect::>(); + .collect::>(); for w in without_dmg { self.players.remove_entry(&w); } @@ -72,27 +75,13 @@ impl Session { fn add_player(&mut self, player_name: &str, player_id: usize) { self.players - .insert(PlayerName(player_name.to_owned()), Player::new(player_id)); + .insert(player_name.to_owned(), Player::new(player_id)); } } -fn merge_stats(a : &PlayerStatisticsVec, b : &PlayerStatisticsVec) -> PlayerStatisticsVec { - let merged = [&a[..], &b[..]].concat().iter().fold( - HashMap::::new(), - |mut acc, stat| { - acc.entry(stat.player.clone()) - .and_modify(|s| { - s.damage += stat.damage; - s.time_in_combat += stat.time_in_combat; - s.dps = s.dps(); - }) - .or_insert(stat.clone()); - acc - }, - ); - - - return merged.iter().map(|(_, v)| v.clone()).collect() +#[derive(Default)] +pub struct MeterConfig { + pub skip_non_party_members: bool, } pub struct Meter { @@ -100,36 +89,55 @@ pub struct Meter { zone_session: Option, last_fight_session: Session, main_player_id: Option, + party: Option, + config: MeterConfig, } impl Meter { pub fn new() -> Self { Self { - zone_history: Vec::new(), + zone_history: PlayerStatisticsVec::new(), zone_session: None, last_fight_session: Session::new(), main_player_id: None, + party: None, + config: Default::default(), } } + pub fn configure(&mut self, config: MeterConfig) { + self.config = config; + } + + fn stats_filter(&self, player: &(&String, &Player)) -> bool { + if self.config.skip_non_party_members { + let is_main_player = if let Some(id) = &self.main_player_id { *id == player.1.id } else { false }; + let is_in_party = if let Some(party) = &self.party { party.includes(&player.0) } else { false }; + + return is_main_player || is_in_party; + } + + true + } + fn zone_session_mut(&mut self) -> Option<&mut Session> { match &mut self.zone_session { Some(s) => Some(s), - None => None + None => None, } } fn zone_session(&self) -> Option<&Session> { match &self.zone_session { Some(s) => Some(s), - None => None + None => None, } } fn sessions_mut(&mut self) -> Option<(&mut Session, &mut Session)> { match &mut self.zone_session { Some(s) => Some((s, &mut self.last_fight_session)), - None => None + None => None, } } @@ -142,23 +150,27 @@ impl Meter { fn new_session(&mut self) { if let Some(zone) = self.zone_session() { - self.zone_history = merge_stats(&self.zone_history, &zone.stats()); + self.zone_history = PlayerStatisticsVec::merged( + &self.zone_history, + &zone.stats(|p| self.stats_filter(p)), + ); } - self.zone_session = Some(Session::new()); self.last_fight_session = Session::new(); } #[allow(unused)] fn combat_state(&self) -> CombatState { - if self.last_fight_session + if self + .last_fight_session .players() .iter() - .any(|p| p.combat_state() == CombatState::InCombat) { - return CombatState::InCombat; - } + .any(|p| p.combat_state() == CombatState::InCombat) + { + return CombatState::InCombat; + } - CombatState::OutOfCombat + CombatState::OutOfCombat } } @@ -167,10 +179,7 @@ impl PlayerEvents for Meter { let (zone, last_fight) = self.sessions_mut()?; let las_fight_session_player = last_fight.get_player_by_id(player_id)?; let zone_player = zone.get_player_by_id(player_id)?; - Some(vec![ - zone_player, - las_fight_session_player, - ]) + Some(vec![zone_player, las_fight_session_player]) } fn register_main_player(&mut self, name: &str, id: usize) { @@ -213,13 +222,12 @@ impl PlayerEvents for Meter { Some(()) } - } impl ZoneStats for Meter { - fn get_zone_session(&self) -> Option> { + fn get_zone_session(&self) -> Option { let last_session = self.zone_session()?; - Some(last_session.stats()) + Some(last_session.stats(|p| self.stats_filter(p))) } fn new_zone_session(&mut self) -> Option<()> { @@ -231,14 +239,17 @@ impl ZoneStats for Meter { fn get_overall_session(&self) -> Option { if let Some(zone) = self.zone_session() { - return Some(merge_stats(&self.zone_history, &zone.stats())); + return Some(PlayerStatisticsVec::merged( + &self.zone_history, + &zone.stats(|p| self.stats_filter(p)), + )); } None } fn reset(&mut self) { - self.zone_history = vec![]; + self.zone_history = PlayerStatisticsVec::new(); self.zone_session = None; self.last_fight_session = Session::new(); self.main_player_id = None; @@ -246,7 +257,7 @@ impl ZoneStats for Meter { fn get_last_fight_session(&self) -> Option { let last_session = &self.last_fight_session; - Some(last_session.stats()) + Some(last_session.stats(|p| self.stats_filter(p))) } fn new_last_fight_session(&mut self) -> Option<()> { @@ -255,6 +266,30 @@ impl ZoneStats for Meter { } } +impl traits::PartyEvents for Meter { + fn register_new_party( + &mut self, + player_names: &std::vec::Vec, + id: usize, + ) -> Option<()> { + self.party = Some(types::Party::new(id, player_names)); + + Some(()) + } + + fn register_new_member(&mut self, player_name: &str) -> Option<()> { + if let Some(party) = &mut self.party { + party.add_member(player_name); + } + Some(()) + } + + fn register_party_disbanded(&mut self) -> Option<()> { + self.party = None; + Some(()) + } +} + #[test] fn test_meter() { let mut meter = Meter::new(); @@ -263,8 +298,4 @@ fn test_meter() { meter.register_main_player("name", 0); assert!(meter.get_zone_session().is_some()); - assert_eq!( - meter.get_zone_session().unwrap()[0].player, - "name".to_owned() - ); } diff --git a/src/meter/traits.rs b/src/meter/traits.rs index 6679188..d78c828 100644 --- a/src/meter/traits.rs +++ b/src/meter/traits.rs @@ -1,4 +1,4 @@ -use super::types::PlayerStatistics; +use super::types::PlayerStatisticsVec; #[derive(Debug, PartialEq)] pub enum CombatState { @@ -69,11 +69,17 @@ pub trait PlayerEvents { pub trait ZoneStats { fn reset(&mut self); - fn get_zone_session(&self) -> Option>; + fn get_zone_session(&self) -> Option; fn new_zone_session(&mut self) -> Option<()>; - fn get_overall_session(&self) -> Option>; + fn get_overall_session(&self) -> Option; - fn get_last_fight_session(&self) -> Option>; + fn get_last_fight_session(&self) -> Option; fn new_last_fight_session(&mut self) -> Option<()>; } + +pub trait PartyEvents { + fn register_new_party(&mut self, player_names: &std::vec::Vec, id: usize) -> Option<()>; + fn register_new_member(&mut self, player_name: &str) -> Option<()>; + fn register_party_disbanded(&mut self) -> Option<()>; +} \ No newline at end of file diff --git a/src/meter/types.rs b/src/meter/types.rs index d25648c..f018abe 100644 --- a/src/meter/types.rs +++ b/src/meter/types.rs @@ -1,5 +1,37 @@ +use std::collections::HashMap; + +use cpython::PythonObject; +use cpython::ToPyObject; +use cpython::Python; +use cpython::PyObject; +use cpython::PyDict; +use cpython::PyList; + use super::traits::DamageStats; +#[derive(Debug, PartialEq, Clone)] +pub struct Party { + pub id: usize, + pub members: Vec +} + +impl Party { + pub fn new(id: usize, members: &std::vec::Vec) -> Self { + Self { + id, + members: members.clone(), + } + } + + pub fn add_member(&mut self, member_name: &str) { + self.members.push(member_name.to_string()); + } + + pub fn includes(&self, other: &str) -> bool { + return self.members.iter().find(|m| **m == other).is_some(); + } +} + #[derive(Debug, PartialEq, Clone)] pub struct PlayerStatistics { pub player: String, @@ -8,7 +40,44 @@ pub struct PlayerStatistics { pub dps: f32, } -pub type PlayerStatisticsVec = Vec; +#[derive(Debug, PartialEq, Clone)] +pub struct PlayerStatisticsVec { + _vec: Vec +} + +impl PlayerStatisticsVec { + pub fn new() -> Self { + Self { + _vec: vec![] + } + } + + pub fn from(player_statistics_vec: Vec) -> Self { + Self { + _vec: player_statistics_vec + } + } + + pub fn merged(a: &Self, b: &Self) -> Self { + let merged = [&a._vec[..], &b._vec[..]].concat().iter().fold( + HashMap::::new(), + |mut acc, stat| { + acc.entry(stat.player.clone()) + .and_modify(|s| { + s.damage += stat.damage; + s.time_in_combat += stat.time_in_combat; + s.dps = s.dps(); + }) + .or_insert(stat.clone()); + acc + }, + ); + + Self { + _vec: merged.iter().map(|(_, v)| v.clone()).collect() + } + } +} impl DamageStats for PlayerStatistics { fn damage(&self) -> f32 { @@ -18,3 +87,38 @@ impl DamageStats for PlayerStatistics { self.time_in_combat } } + + +impl ToPyObject for PlayerStatistics { + type ObjectType = PyObject; + fn to_py_object(&self, py: Python) -> Self::ObjectType { + let stats = PyDict::new(py); + + stats + .set_item(py, "player", self.player.to_py_object(py)) + .unwrap(); + stats + .set_item(py, "damage", self.damage.to_py_object(py)) + .unwrap(); + stats + .set_item(py, "time_in_combat", self.time_in_combat.to_py_object(py)) + .unwrap(); + stats + .set_item(py, "dps", self.dps.to_py_object(py)) + .unwrap(); + + stats.into_object() + } +} + +impl ToPyObject for PlayerStatisticsVec { + type ObjectType = PyList; + + fn into_py_object(self, py: Python) -> Self::ObjectType { + self._vec.into_py_object(py) + } + + fn to_py_object(&self, py: Python) -> Self::ObjectType { + self._vec.clone().into_py_object(py) + } +} \ No newline at end of file