From 74503083a04d14f64f21348157946f97916df13d Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Fri, 13 Sep 2019 13:40:30 +0200 Subject: [PATCH] +traits for player and meter --- gui/src/engine.py | 8 +-- gui/src/main.py | 14 +++--- meter.py | 8 +-- src/lib.rs | 85 ++++++++++++++++---------------- src/meter/mod.rs | 115 +++++++++++++++----------------------------- src/meter/player.rs | 50 +++---------------- src/meter/traits.rs | 56 +++++++++++++++++++++ src/meter/types.rs | 7 +++ 8 files changed, 166 insertions(+), 177 deletions(-) create mode 100644 src/meter/traits.rs create mode 100644 src/meter/types.rs diff --git a/gui/src/engine.py b/gui/src/engine.py index c9f5c02..0b9de08 100644 --- a/gui/src/engine.py +++ b/gui/src/engine.py @@ -15,7 +15,7 @@ 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_instance_session(): +def get_zone_session(): if TESTING_ENABLED: session = [ {'player': 'A', 'damage': 1234.02, 'time_in_combat': 12.0, 'dps': 12.4234}, @@ -24,12 +24,12 @@ def get_instance_session(): {'player': 'D', 'damage': 0, 'time_in_combat': 12.0, 'dps': 0} ] else: - session = libmeter.get_instance_session() + session = libmeter.get_zone_session() return [Stat(s['player'], s['damage'], s['time_in_combat'], s['dps']) for s in session] -def reset_instance_session(): - libmeter.reset_instance_session() +def new_zone_session(): + libmeter.new_zone_session() def initialize(): if TESTING_ENABLED: diff --git a/gui/src/main.py b/gui/src/main.py index 5533fa7..01540d6 100644 --- a/gui/src/main.py +++ b/gui/src/main.py @@ -12,8 +12,8 @@ from PySide2.QtWidgets import QLabel import clipboard from table import Table -from engine import get_instance_session -from engine import reset_instance_session +from engine import get_zone_session +from engine import new_zone_session class BottomButtons(QWidget): def __init__(self, table): @@ -40,7 +40,7 @@ class BottomButtons(QWidget): self.close_button.setObjectName('BottomButtons') def copy(self): - clip = "Damage: Current instance\n" + clip = "Damage: Current zone\n" for i in range(self.table.rowCount()): clip += '{}. {} {}-{}'.format(i+1, self.table.item(i, 0).text( ), self.table.item(i, 1).text(), self.table.item(i, 2).text()) @@ -48,7 +48,7 @@ class BottomButtons(QWidget): clipboard.copy(clip) def reset(self): - reset_instance_session() + new_zone_session() def close(self): sys.exit(0) @@ -59,7 +59,7 @@ class MainWidget(QWidget): self.mouse_pos = None - self.phoneLabel = QLabel("Damage: Current instance", self) + self.phoneLabel = QLabel("Damage: Current zone", self) self.table = Table() self.bottom_buttons = BottomButtons(self.table) @@ -70,10 +70,10 @@ class MainWidget(QWidget): self.layout.addWidget(self.bottom_buttons) self.setLayout(self.layout) - self.table.fill(get_instance_session()) + self.table.fill(get_zone_session()) timer = QTimer(self) - timer.timeout.connect(lambda: self.table.fill(get_instance_session())) + timer.timeout.connect(lambda: self.table.fill(get_zone_session())) timer.start(500) def mousePressEvent(self, event): diff --git a/meter.py b/meter.py index c8fd29d..fcd74d3 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_instance_session(): - session = libmeter.get_instance_session() +def get_zone_session(): + session = libmeter.get_zone_session() # 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_instance_session()) + self.table.fill(get_zone_session()) 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_instance_session())) + timer.timeout.connect(lambda: self.table.fill(get_zone_session())) timer.start(5000) def copy(self): diff --git a/src/lib.rs b/src/lib.rs index 10cad31..ee1c827 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,18 +20,13 @@ use packet_sniffer::UdpPacket; mod game_protocol; mod meter; +use meter::ZoneStats; +use meter::PlayerEvents; + lazy_static! { static ref METER: Mutex = Mutex::new(meter::Meter::new()); } -impl ToPyObject for meter::DPS { - type ObjectType = cpython::PyFloat; - - fn to_py_object(&self, py: Python) -> Self::ObjectType { - self.value().to_py_object(py) - } -} - impl ToPyObject for meter::PlayerStatistics { type ObjectType = PyObject; fn to_py_object(&self, py: Python) -> Self::ObjectType { @@ -49,9 +44,9 @@ impl ToPyObject for meter::PlayerStatistics { } } -fn get_instance_session(py: Python) -> PyResult { +fn get_zone_session(py: Python) -> PyResult { let meter = &mut METER.lock().unwrap(); - meter.get_instance_session().map_or_else( + meter.get_zone_session().map_or_else( || Ok(PyList::new(py, Vec::::new().as_slice())), |v| { Ok(PyList::new( @@ -65,10 +60,10 @@ fn get_instance_session(py: Python) -> PyResult { ) } -fn reset_instance_session(_py: Python) -> PyResult { +fn new_zone_session(_py: Python) -> PyResult { let meter = &mut METER.lock().unwrap(); - meter.reset_instance_session(); + meter.new_zone_session(); Ok(0) } @@ -92,7 +87,8 @@ fn initialize(_py: Python) -> PyResult { if packet.destination_port != 5056 && packet.source_port != 5056 { continue; } - register_messages(&game_protocol::decode(&packet.payload)); + let meter = &mut METER.lock().unwrap(); + register_messages(meter, &game_protocol::decode(&packet.payload)); } } }); @@ -100,34 +96,33 @@ fn initialize(_py: Python) -> PyResult { Ok(0) } -fn register_messages(messages: &Vec) { - let mut meter = &mut METER.lock().unwrap(); +fn register_messages(meter: &mut meter::Meter, messages: &Vec) { messages .iter() - .for_each(|message| register_message(&mut meter, &message)); + .for_each(|message| register_message(meter, &message)); } -fn register_message(meter: &mut meter::Meter, message: &game_protocol::Message) { +fn register_message(events: &mut PlayerEvents, message: &game_protocol::Message) { debug!("Found message {:?}", message); match message { - game_protocol::Message::Leave(msg) => meter.register_leave(msg.source).unwrap_or(()), + game_protocol::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()), game_protocol::Message::NewCharacter(msg) => { - meter.register_player(&msg.character_name, msg.source) + events.register_player(&msg.character_name, msg.source) } game_protocol::Message::CharacterStats(msg) => { - meter.register_main_player(&msg.character_name, msg.source) + events.register_main_player(&msg.character_name, msg.source) } - game_protocol::Message::HealthUpdate(msg) => meter + 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(_) => meter.register_combat_leave(msg.source).unwrap_or(()), - None => meter.register_combat_enter(msg.source).unwrap_or(()), + Some(_) => events.register_combat_leave(msg.source).unwrap_or(()), + None => events.register_combat_enter(msg.source).unwrap_or(()), } }, game_protocol::Message::Died(msg) => { - meter.register_combat_leave(msg.source).unwrap_or(()) + events.register_combat_leave(msg.source).unwrap_or(()) } _ => {} } @@ -136,11 +131,11 @@ fn register_message(meter: &mut meter::Meter, message: &game_protocol::Message) 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, "reset_instance_session", py_fn!(py, reset_instance_session()))?; + m.add(py, "new_zone_session", py_fn!(py, new_zone_session()))?; m.add( py, - "get_instance_session", - py_fn!(py, get_instance_session()), + "get_zone_session", + py_fn!(py, get_zone_session()), )?; Ok(()) }); @@ -158,6 +153,10 @@ mod tests { 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); } } @@ -204,7 +203,7 @@ mod tests { fn test_empty_session() { let guard = Python::acquire_gil(); let py = guard.python(); - assert_eq!(get_instance_session(py).unwrap().len(py), 0); + assert_eq!(get_zone_session(py).unwrap().len(py), 0); } #[test] @@ -214,8 +213,8 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new())); - let instance_session = get_instance_session(py).unwrap(); - assert_eq!(instance_session.len(py), 1); + let zone_session = get_zone_session(py).unwrap(); + assert_eq!(zone_session.len(py), 1); } #[test] @@ -225,8 +224,8 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new())); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!(dict.len(py), 4); assert_eq!( @@ -270,8 +269,8 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new())); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!( dict.get_item(py, &"player") @@ -292,8 +291,8 @@ mod tests { helpers::register(Message::HealthUpdate(message::HealthUpdate::new())); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!( dict.get_item(py, &"damage") @@ -312,8 +311,8 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new())); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!( dict.get_item(py, &"player") @@ -334,8 +333,8 @@ mod tests { helpers::register(Message::HealthUpdate(message::HealthUpdate::new())); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!( dict.get_item(py, &"damage") @@ -347,9 +346,9 @@ mod tests { ); - reset_instance_session(py).unwrap(); - let instance_session = get_instance_session(py).unwrap(); - let stat = instance_session.get_item(py, 0); + new_zone_session(py).unwrap(); + let zone_session = get_zone_session(py).unwrap(); + let stat = zone_session.get_item(py, 0); let dict = stat.cast_as::(py).unwrap(); assert_eq!( dict.get_item(py, &"damage") diff --git a/src/meter/mod.rs b/src/meter/mod.rs index 0c5fff7..3f71eaa 100644 --- a/src/meter/mod.rs +++ b/src/meter/mod.rs @@ -7,41 +7,21 @@ use std::collections::VecDeque; use log::*; mod player; +mod traits; +mod types; use player::Player; -#[derive(Debug, Copy, Clone, PartialEq)] -pub struct DPS(f32); - -impl DPS { - fn new(damage: f32, time: f32) -> Self { - if time == 0.0 { - return Self(0.0) - } - - Self(damage / time * 1000.0) - } - - pub fn value(&self) -> f32 { - self.0 - } -} +pub use traits::*; +pub use types::*; #[derive(Hash, Eq, PartialEq, Clone)] -struct PlayerName(String); +pub struct PlayerName(String); pub struct Session { players: HashMap, } -#[derive(Debug, PartialEq)] -pub struct PlayerStatistics { - pub player: String, - pub damage: f32, - pub time_in_combat: f32, - pub dps: DPS -} - impl Session { fn new() -> Self { Self { @@ -65,9 +45,9 @@ impl Session { .iter() .map(|(name, player)| PlayerStatistics { player: name.0.to_owned(), - damage: player.get_damage_dealt(), - time_in_combat: player.get_time_elapsed(), - dps: DPS::new(player.get_damage_dealt(), player.get_time_elapsed()) + damage: player.damage(), + time_in_combat: player.time_in_combat(), + dps: player.dps() }) .collect() } @@ -85,102 +65,83 @@ impl Session { } pub struct Meter { - instance_sessions: VecDeque, + zone_sessions: VecDeque, main_player_id: Option, } impl Meter { pub fn new() -> Self { Self { - instance_sessions: VecDeque::new(), + zone_sessions: VecDeque::new(), main_player_id: None, } } +} - pub fn register_main_player(&mut self, name: &str, id: usize) { + +impl PlayerEvents for Meter { + fn get_player_in_zone(&mut self, player_id: usize) -> Option<&mut Player> { + let session = self.zone_sessions.back_mut()?; + session.get_player_by_id(player_id) + } + + fn register_main_player(&mut self, name: &str, id: usize) { debug!("Main player {} registerd with id {}", name, id); self.main_player_id = Some(id); - match self.instance_sessions.back_mut() { + match self.zone_sessions.back_mut() { Some(session) => session.add_player(name, id), None => { let mut session = Session::new(); session.add_player(name, id); - self.instance_sessions.push_back(session); + self.zone_sessions.push_back(session); } } } - pub fn register_leave(&mut self, id: usize) -> Option<()> { + 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 instance"); - self.instance_sessions.push_back(Session::new()); + debug!("New session, main player left the zone"); + self.zone_sessions.push_back(Session::new()); } Some(()) } - pub fn register_player(&mut self, name: &str, id: usize) { - if self.instance_sessions.is_empty() { + fn register_player(&mut self, name: &str, id: usize) { + if self.zone_sessions.is_empty() { debug!("New session"); - self.instance_sessions.push_back(Session::new()); + self.zone_sessions.push_back(Session::new()); } - let session = self.instance_sessions.back_mut().unwrap(); + let session = self.zone_sessions.back_mut().unwrap(); session.add_player(name, id); } +} - pub fn register_damage_dealt(&mut self, player_id: usize, damage: f32) -> Option<()> { - let session = self.instance_sessions.back_mut()?; - let player = session.get_player_by_id(player_id)?; - if damage < 0.0 { - player.register_damage_dealt(f32::abs(damage)); - } - - Some(()) - } - - pub fn register_combat_enter(&mut self, player_id: usize) -> Option<()> { - let session = self.instance_sessions.back_mut()?; - let player = session.get_player_by_id(player_id)?; - - player.enter_combat(); - - Some(()) - } - - pub fn register_combat_leave(&mut self, player_id: usize) -> Option<()> { - let session = self.instance_sessions.back_mut()?; - let player = session.get_player_by_id(player_id)?; - - player.leave_combat(); - - Some(()) - } - - pub fn get_instance_session(&self) -> Option> { - let last_session = self.instance_sessions.back()?; +impl ZoneStats for Meter { + fn get_zone_session(&self) -> Option> { + let last_session = self.zone_sessions.back()?; Some(last_session.stats()) } - pub fn reset_instance_session(&mut self) -> Option<()> { - let last_session = self.instance_sessions.back()?; + fn new_zone_session(&mut self) -> Option<()> { + let last_session = self.zone_sessions.back()?; let new_session = Session::from(&last_session); - self.instance_sessions.push_back(new_session); + self.zone_sessions.push_back(new_session); Some(()) } } - #[test] fn test_meter() { let mut meter = Meter::new(); - assert_eq!(meter.get_instance_session(), None); + assert_eq!(meter.get_zone_session(), None); meter.register_main_player("name", 0); - assert!(meter.get_instance_session().is_some()); - assert_eq!(meter.get_instance_session().unwrap()[0].player, "name".to_owned()); + assert!(meter.get_zone_session().is_some()); + assert_eq!(meter.get_zone_session().unwrap()[0].player, "name".to_owned()); } \ No newline at end of file diff --git a/src/meter/player.rs b/src/meter/player.rs index f6c2ee2..e8ebcb3 100644 --- a/src/meter/player.rs +++ b/src/meter/player.rs @@ -2,6 +2,8 @@ use std::sync::{Arc, Mutex}; use timer; +use super::traits::DamageStats; + #[derive(PartialEq)] enum CombatState { @@ -65,50 +67,14 @@ impl Player pub fn leave_combat(&mut self) { *self.combat_state.lock().unwrap() = CombatState::OutOfCombat; } - - pub fn get_damage_dealt(&self) -> f32 { self.damage_dealt } - - pub fn get_time_elapsed(&self) -> f32 { - *self.time_elapsed.lock().unwrap() - } } - -#[cfg(test)] -mod test -{ - use super::*; - use std::thread; +impl DamageStats for Player { + fn damage(&self) -> f32 { + self.damage_dealt + } - #[allow(unused)] - fn get_test_player() -> Player { - Player::new(1) - } - - #[test] - fn test_player_initial_stats() { - let player = Player::new(1); - - assert_eq!(player.get_damage_dealt(), 0.0); - } - - #[test] - fn test_damage_when_in_combat() { - let mut player = get_test_player(); - - player.enter_combat(); - player.register_damage_dealt(1000.0); - assert_eq!(player.get_damage_dealt(), 1000.0); - } - - #[test] - fn test_damage_after_tenth_second() { - let mut player = get_test_player(); - - player.register_damage_dealt(1000.0); - player.enter_combat(); - - thread::sleep(std::time::Duration::from_millis(100)); - assert_eq!(player.get_damage_dealt(), 1000.0); + fn time_in_combat(&self) -> f32 { + *self.time_elapsed.lock().unwrap() } } \ No newline at end of file diff --git a/src/meter/traits.rs b/src/meter/traits.rs new file mode 100644 index 0000000..db6a6b2 --- /dev/null +++ b/src/meter/traits.rs @@ -0,0 +1,56 @@ +use super::types::PlayerStatistics; +use super::Player; + +pub trait DamageStats { + fn damage(&self) -> f32; + + fn time_in_combat(&self) -> f32; + + fn dps(&self) -> f32 { + if self.time_in_combat() == 0.0 { + 0.0 + } else { + self.damage() / self.time_in_combat() * 1000.0 + } + } +} + +pub trait PlayerEvents { + fn get_player_in_zone(&mut self, player_id: usize) -> Option<&mut Player>; + + fn register_main_player(&mut self, name: &str, id: usize); + + fn register_leave(&mut self, id: usize) -> Option<()>; + + fn register_player(&mut self, name: &str, id: usize); + + fn register_damage_dealt(&mut self, player_id: usize, damage: f32) -> Option<()> { + let player = self.get_player_in_zone(player_id)?; + if damage < 0.0 { + player.register_damage_dealt(f32::abs(damage)); + } + + Some(()) + } + + fn register_combat_enter(&mut self, player_id: usize) -> Option<()> { + let player = self.get_player_in_zone(player_id)?; + + player.enter_combat(); + + Some(()) + } + + fn register_combat_leave(&mut self, player_id: usize) -> Option<()> { + let player = self.get_player_in_zone(player_id)?; + + player.leave_combat(); + + Some(()) + } +} + +pub trait ZoneStats { + fn get_zone_session(&self) -> Option>; + fn new_zone_session(&mut self) -> Option<()>; +} diff --git a/src/meter/types.rs b/src/meter/types.rs new file mode 100644 index 0000000..b6917db --- /dev/null +++ b/src/meter/types.rs @@ -0,0 +1,7 @@ +#[derive(Debug, PartialEq)] +pub struct PlayerStatistics { + pub player: String, + pub damage: f32, + pub time_in_combat: f32, + pub dps: f32 +} \ No newline at end of file