diff --git a/Cargo.toml b/Cargo.toml index bfeaf0f..ac6b78a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,4 +22,6 @@ timer = "0.1" chrono = "0.4" log = { version = "0.4", features = ["std"] } lazy_static = "1.2" + +[dev-dependencies] fake_clock = "0.3.0" \ No newline at end of file diff --git a/gui/src/engine.py b/gui/src/engine.py index d07a835..c9cb676 100644 --- a/gui/src/engine.py +++ b/gui/src/engine.py @@ -6,6 +6,13 @@ from config import config TESTING_ENABLED = bool(os.getenv('TESTING')) +class StatType: + Unknown = 0 + LastFight = 1 + Zone = 2 + Overall = 3 + + class DamageStat: def __init__(self, name, damage, time_in_combat, dps, precentage): self.name = name @@ -50,7 +57,7 @@ def with_precentage(session): return session -def get_zone_session(): +def zone_stats(): if TESTING_ENABLED: session = [ {'player': 'A'*20, 'damage': 1234.02, @@ -60,31 +67,31 @@ def get_zone_session(): {'player': 'D'*20, 'damage': 0, 'time_in_combat': 12.0, 'dps': 0} ] else: - session = libmeter.get_zone_session() + session = libmeter.stats(StatType.Zone) return stats(session) -def get_overall_session(): +def overall_stats(): if TESTING_ENABLED: session = [ {'player': 'overall', 'damage': 1234.02, 'time_in_combat': 12.0, 'dps': 12.4234}, ] else: - session = libmeter.get_overall_session() + session = libmeter.stats(StatType.Overall) return stats(session) -def get_last_fight_session(): +def last_fight_stats(): if TESTING_ENABLED: session = [ {'player': 'last fight', 'damage': 1234.02, 'time_in_combat': 12.0, 'dps': 12.4234}, ] else: - session = libmeter.get_last_fight_session() + session = libmeter.stats(StatType.LastFight) return stats(session) @@ -95,14 +102,14 @@ def get_party_members(): return libmeter.get_players_in_party() -def new_zone_session(): - libmeter.new_zone_session() +def reset_zone_stats(): + libmeter.reset_zone_stats() -def new_last_fight_session(): - libmeter.new_last_fight_session() +def reset_last_fight_stats(): + libmeter.reset_last_fight_stats() -def reset_sessions(): - libmeter.reset_sessions() +def reset_stats(): + libmeter.reset_stats() def initialize(): if TESTING_ENABLED: diff --git a/gui/src/main.py b/gui/src/main.py index 4459add..a49c727 100644 --- a/gui/src/main.py +++ b/gui/src/main.py @@ -60,9 +60,9 @@ class BottomButtons(QWidget): def reset(self): reset = { - Mode.CURRENT_ZONE: engine.new_zone_session, - Mode.LAST_FIGHT: engine.new_last_fight_session, - Mode.OVERALL: engine.reset_sessions + Mode.CURRENT_ZONE: engine.reset_zone_stats, + Mode.LAST_FIGHT: engine.reset_last_fight_stats, + Mode.OVERALL: engine.reset_stats } reset[self.mode()]() @@ -126,9 +126,9 @@ class MainWidget(QWidget): def session(self): sessions = { - Mode.CURRENT_ZONE: engine.get_zone_session, - Mode.LAST_FIGHT: engine.get_last_fight_session, - Mode.OVERALL: engine.get_overall_session + Mode.CURRENT_ZONE: engine.zone_stats, + Mode.LAST_FIGHT: engine.last_fight_stats, + Mode.OVERALL: engine.overall_stats } return sessions[self.mode.currentText()]() diff --git a/lib/packet-sniffer/src/lib.rs b/lib/packet-sniffer/src/lib.rs index ce5e83f..06c770e 100644 --- a/lib/packet-sniffer/src/lib.rs +++ b/lib/packet-sniffer/src/lib.rs @@ -37,7 +37,7 @@ pub fn receive(tx: Sender) { .into_iter() .filter(|i| !i.is_loopback()); - debug!("Found interfaces: {:?}", interfaces); + info!("Found interfaces: {:?}", interfaces); for interface in interfaces { let tx = shared_tx.clone(); diff --git a/meter.py b/meter.py index fcd74d3..c84972f 100644 --- a/meter.py +++ b/meter.py @@ -26,8 +26,8 @@ class Stat: return self.name == other.name and self.damage == other.damage and self.time_in_combat == other.time_in_combat and self.dps == other.dps -def get_zone_session(): - session = libmeter.get_zone_session() +def zone_stats(): + session = libmeter.zone_stats() # session = [ # {'player': 'A', 'damage': 1234.02, 'time_in_combat': 12.0, 'dps': 12.4234}, # {'player': 'B', 'damage': 5435.02, 'time_in_combat': 12.0, 'dps': 12}, @@ -94,12 +94,12 @@ class MyWidget(QWidget): self.layout.addWidget(self.refresh_button) self.setLayout(self.layout) - self.table.fill(get_zone_session()) + self.table.fill(zone_stats()) self.copy_button.clicked.connect(self.copy) self.refresh_button.clicked.connect(self.clear) timer = QTimer(self) - timer.timeout.connect(lambda: self.table.fill(get_zone_session())) + timer.timeout.connect(lambda: self.table.fill(zone_stats())) timer.start(5000) def copy(self): diff --git a/src/core.rs b/src/core.rs index 68a0d14..216c12c 100644 --- a/src/core.rs +++ b/src/core.rs @@ -16,59 +16,55 @@ use packet_sniffer::UdpPacket; use crate::game_protocol; use crate::meter; +use meter::GameStats; +use meter::LastFightStats; +use meter::OverallStats; use meter::PartyEvents; use meter::PlayerEvents; use meter::ZoneStats; +pub use meter::StatType; + lazy_static! { static ref METER: Mutex = Mutex::new(meter::Meter::new()); } -pub fn get_zone_session(py: Python) -> PyResult { +pub fn stats(py: Python, stat_type: StatType) -> 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)), - ) + match stat_type { + StatType::Zone => meter.zone_stats().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ), + StatType::LastFight => meter.last_fight_stats().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ), + StatType::Overall => meter.overall_stats().map_or_else( + || Ok(PyList::new(py, Vec::::new().as_slice())), + |v| Ok(v.into_py_object(py)), + ), + _ => { + error!("Unexpected stats requested."); + Ok(PyList::new(py, Vec::::new().as_slice())) + } + } } -pub fn get_overall_session(py: Python) -> PyResult { +pub fn reset(_py: Python, stat_type: StatType) -> 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(); - + match stat_type { + StatType::Zone => { + meter.reset_zone_stats(); + } + StatType::LastFight => { + meter.reset_last_fight_stats(); + } + StatType::Overall => { + meter.reset_stats(); + } + _ => error!("Unexpected stat to reset."), + } Ok(0) } @@ -83,16 +79,19 @@ pub fn get_players_in_party(py: Python) -> PyResult { pub fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult { CombinedLogger::init(vec![WriteLogger::new( - LevelFilter::Trace, + LevelFilter::Info, Config::default(), File::create("damage-meter.log").unwrap(), )]) .unwrap(); - configure(&mut METER.lock().unwrap(), meter::MeterConfig { - skip_non_party_members, - ..Default::default() - }); + configure( + &mut METER.lock().unwrap(), + meter::MeterConfig { + skip_non_party_members, + ..Default::default() + }, + ); thread::spawn(move || { let (tx, rx): (Sender, Receiver) = channel(); @@ -126,7 +125,7 @@ fn register_messages(meter: &mut meter::Meter, messages: &Vec events.register_leave(msg.source).unwrap_or(()), game_protocol::Message::NewCharacter(msg) => { @@ -152,9 +151,9 @@ fn register_message(events: &mut meter::Meter, message: &game_protocol::Message) game_protocol::Message::PartyDisbanded(_) => { events.register_party_disbanded().unwrap_or(()) } - game_protocol::Message::FameUpdate(msg) => { - events.register_fame_gain(msg.source, msg.fame).unwrap_or(()) - } + game_protocol::Message::FameUpdate(msg) => events + .register_fame_gain(msg.source, msg.fame) + .unwrap_or(()), _ => {} } } @@ -173,7 +172,7 @@ mod tests { pub fn init() -> cpython::GILGuard { let meter = &mut METER.lock().unwrap(); - meter.reset(); + meter.reset_stats(); super::configure(meter, Default::default()); @@ -200,14 +199,14 @@ mod tests { } pub fn get_damage_dealer_in_zone_by_index(py: Python, index: usize) -> PyDict { - let zone_session = get_zone_session(py).unwrap(); + let zone_session = stats(py, StatType::Zone).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); + let zone_session_len = stats(py, StatType::Zone).unwrap().len(py); for idx in 0..zone_session_len { let player = get_damage_dealer_in_zone_by_index(py, idx); @@ -219,14 +218,14 @@ mod tests { } pub fn get_player_overall_index(py: Python, index: usize) -> PyDict { - let zone_session = get_overall_session(py).unwrap(); + let zone_session = stats(py, StatType::Overall).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); + let zone_session_len = stats(py, StatType::Overall).unwrap().len(py); for idx in 0..zone_session_len { let player = get_player_overall_index(py, idx); @@ -238,14 +237,14 @@ mod tests { } pub fn get_player_last_fight_index(py: Python, index: usize) -> PyDict { - let zone_session = get_last_fight_session(py).unwrap(); + let zone_session = stats(py, StatType::LastFight).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); + let zone_session_len = stats(py, StatType::LastFight).unwrap().len(py); for idx in 0..zone_session_len { let player = get_player_last_fight_index(py, idx); @@ -258,7 +257,7 @@ mod tests { pub fn get_players_in_party() -> Vec { let meter = &mut METER.lock().unwrap(); - meter.get_players_in_party().unwrap_or(vec![]) + meter.get_players_in_party().unwrap_or(vec![]) } pub fn get_string(py: Python, stats: &PyDict, key: &str) -> String { @@ -281,11 +280,7 @@ mod tests { } pub fn get_number(py: Python, stats: &PyDict, key: &str) -> u32 { - stats - .get_item(py, key) - .unwrap() - .extract(py) - .unwrap() + stats.get_item(py, key).unwrap().extract(py).unwrap() } } @@ -419,7 +414,7 @@ mod tests { let guard = helpers::init(); let py = guard.python(); - assert_eq!(get_zone_session(py).unwrap().len(py), 0); + assert_eq!(stats(py, StatType::Zone).unwrap().len(py), 0); } #[test] @@ -429,7 +424,7 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - let zone_session = get_zone_session(py).unwrap(); + let zone_session = stats(py, StatType::Zone).unwrap(); assert_eq!(zone_session.len(py), 1); } @@ -513,7 +508,7 @@ mod tests { 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(); + reset(py, StatType::Zone).unwrap(); let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); } @@ -732,12 +727,14 @@ mod tests { }); helpers::register(Message::CharacterStats(message::CharacterStats::new_named( - "main_player", 1, + "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, + "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()); @@ -747,25 +744,34 @@ mod tests { 1, ))); - assert_eq!(helpers::get_players_in_party().len(), 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_some()); helpers::register(Message::NewCharacter(message::NewCharacter::new_named( - "yet_another_other_player", 2, + "yet_another_other_player", + 2, ))); - assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none()); + 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))); + helpers::register(Message::PartyJoin(message::PartyJoin::new_named( + &"yet_another_other_player", + 1, + ))); assert_eq!(helpers::get_players_in_party().len(), 3); - assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_some()); + 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()); + assert!( + helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none() + ); assert_eq!(helpers::get_players_in_party().len(), 0); } diff --git a/src/lib.rs b/src/lib.rs index e47a210..ada7a8f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,32 +9,17 @@ mod meter; mod core; -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; use crate::core::get_players_in_party; +use crate::core::initialize; +use crate::core::StatType; +use crate::core::stats; +use crate::core::reset; 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(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( - py, - "get_last_fight_session", - py_fn!(py, get_last_fight_session()), - )?; - m.add(py, "reset_sessions", py_fn!(py, reset_sessions()))?; - m.add( - py, - "new_last_fight_session", - py_fn!(py, new_last_fight_session()), - )?; - m.add(py, "get_zone_session", py_fn!(py, get_zone_session()))?; + m.add(py, "stats", py_fn!(py, stats(stat_type: StatType)))?; + m.add(py, "reset", py_fn!(py, reset(stat_type: StatType)))?; m.add(py, "get_players_in_party", py_fn!(py, get_players_in_party()))?; Ok(()) }); diff --git a/src/meter/mod.rs b/src/meter/mod.rs index dee7e72..4700c36 100644 --- a/src/meter/mod.rs +++ b/src/meter/mod.rs @@ -199,7 +199,7 @@ impl PlayerEvents for Meter { } fn register_main_player(&mut self, name: &str, id: usize) { - debug!("Main player {} registerd with id {}", name, id); + info!("Main player {} registered with id {}", name, id); self.main_player_id = Some(id); if self.zone_session.is_none() { @@ -211,7 +211,7 @@ impl PlayerEvents for Meter { fn register_leave(&mut self, id: usize) -> Option<()> { let main_player_id = self.main_player_id?; if id == main_player_id { - debug!("New session, main player left the zone"); + info!("Main player ({}) left the zone, Creating new zone session.", id); self.zone_session_mut()?.cleanup_players(); self.new_session(); } @@ -221,7 +221,7 @@ impl PlayerEvents for Meter { fn register_player(&mut self, name: &str, id: usize) { if self.zone_session.is_none() { - debug!("New session"); + info!("New player ({}) registered without session, creating new session", name); self.new_session(); } @@ -240,20 +240,34 @@ impl PlayerEvents for Meter { } } +impl LastFightStats for Meter { + fn last_fight_stats(&self) -> Option { + let last_session = &self.last_fight_session; + Some(last_session.stats(|p| self.stats_filter(p))) + } + + fn reset_last_fight_stats(&mut self) -> Option<()> { + self.last_fight_session = Session::from(&self.last_fight_session); + Some(()) + } +} + impl ZoneStats for Meter { - fn get_zone_session(&self) -> Option { + fn zone_stats(&self) -> Option { let last_session = self.zone_session()?; Some(last_session.stats(|p| self.stats_filter(p))) } - fn new_zone_session(&mut self) -> Option<()> { + fn reset_zone_stats(&mut self) -> Option<()> { let last_session = self.zone_session_mut()?; self.zone_session = Some(Session::from(&last_session)); Some(()) } +} - fn get_overall_session(&self) -> Option { +impl OverallStats for Meter { + fn overall_stats(&self) -> Option { if let Some(zone) = self.zone_session() { return Some(PlayerStatisticsVec::merged( &self.zone_history, @@ -263,21 +277,15 @@ impl ZoneStats for Meter { None } +} - fn reset(&mut self) { +impl GameStats for Meter { + fn reset_stats(&mut self) -> Option<()> { self.zone_history = PlayerStatisticsVec::new(); self.zone_session = None; self.last_fight_session = Session::new(); self.main_player_id = None; - } - fn get_last_fight_session(&self) -> Option { - let last_session = &self.last_fight_session; - Some(last_session.stats(|p| self.stats_filter(p))) - } - - fn new_last_fight_session(&mut self) -> Option<()> { - self.last_fight_session = Session::from(&self.last_fight_session); Some(()) } @@ -318,8 +326,8 @@ impl traits::PartyEvents for Meter { fn test_meter() { let mut meter = Meter::new(); - assert_eq!(meter.get_zone_session(), None); + assert_eq!(meter.zone_stats(), None); meter.register_main_player("name", 0); - assert!(meter.get_zone_session().is_some()); + assert!(meter.zone_stats().is_some()); } diff --git a/src/meter/traits.rs b/src/meter/traits.rs index 56cbadd..f22ee56 100644 --- a/src/meter/traits.rs +++ b/src/meter/traits.rs @@ -101,18 +101,23 @@ pub trait PlayerEvents { } } +pub trait LastFightStats { + fn last_fight_stats(&self) -> Option; + fn reset_last_fight_stats(&mut self) -> Option<()>; +} + pub trait ZoneStats { - fn reset(&mut self); + fn zone_stats(&self) -> Option; + fn reset_zone_stats(&mut self) -> Option<()>; +} +pub trait OverallStats { + fn overall_stats(&self) -> Option; +} + +pub trait GameStats { fn get_players_in_party(&self) -> Option>; - - fn get_zone_session(&self) -> Option; - fn new_zone_session(&mut self) -> Option<()>; - - fn get_overall_session(&self) -> Option; - - fn get_last_fight_session(&self) -> Option; - fn new_last_fight_session(&mut self) -> Option<()>; + fn reset_stats(&mut self) -> Option<()>; } pub trait PartyEvents { diff --git a/src/meter/types.rs b/src/meter/types.rs index d93eb62..bdb9b21 100644 --- a/src/meter/types.rs +++ b/src/meter/types.rs @@ -9,10 +9,12 @@ use std::time::Instant; use cpython::PythonObject; use cpython::ToPyObject; +use cpython::FromPyObject; use cpython::Python; use cpython::PyObject; use cpython::PyDict; use cpython::PyList; +use cpython::PyResult; use super::traits::DamageStats; use super::traits::FameStats; @@ -57,6 +59,14 @@ pub struct PlayerStatisticsVec { _vec: Vec } +#[derive(Debug, PartialEq, Copy, Clone)] +pub enum StatType { + LastFight, + Zone, + Overall, + Unknown +} + impl PlayerStatisticsVec { pub fn new() -> Self { Self { @@ -162,4 +172,20 @@ impl ToPyObject for PlayerStatisticsVec { fn to_py_object(&self, py: Python) -> Self::ObjectType { self._vec.clone().into_py_object(py) } -} \ No newline at end of file +} + +impl <'source> FromPyObject<'source> for StatType { + fn extract(py: Python, obj: &'source PyObject) -> PyResult { + match obj.extract(py) { + Ok(n) => { + match n { + 1 => Ok(StatType::LastFight), + 2 => Ok(StatType::Zone), + 3 => Ok(StatType::Overall), + _ => Ok(StatType::Unknown) + } + }, + Err(e) => Err(e) + } + } +}