From ead1da9731e24dff1c351e69b25efc8948aea657 Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Sun, 15 Sep 2019 12:53:05 +0200 Subject: [PATCH] Two players in the zone, overall & last fight interface --- src/lib.rs | 445 ++++++++++++++++++++++++++++++++++++++++---- src/meter/mod.rs | 136 +++++++++++--- src/meter/player.rs | 59 +++--- src/meter/traits.rs | 45 +++-- src/meter/types.rs | 17 +- 5 files changed, 591 insertions(+), 111 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 22f6d3f..980e043 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,8 +11,8 @@ use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::Mutex; use std::thread; -use cpython::{PyDict, PyList, PyObject, PyResult, Python, PythonObject, ToPyObject}; use cpython::PyClone; +use cpython::{PyDict, PyList, PyObject, PyResult, Python, PythonObject, ToPyObject}; use log::*; use simplelog::*; @@ -21,8 +21,8 @@ use packet_sniffer::UdpPacket; mod game_protocol; mod meter; -use meter::ZoneStats; use meter::PlayerEvents; +use meter::ZoneStats; lazy_static! { static ref METER: Mutex = Mutex::new(meter::Meter::new()); @@ -33,13 +33,18 @@ impl ToPyObject for meter::PlayerStatistics { 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)) + stats + .set_item(py, "player", self.player.to_py_object(py)) .unwrap(); - stats.set_item(py, "damage", self.damage.to_py_object(py)) + 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)) + 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.set_item(py, "dps", self.dps.to_py_object(py)).unwrap(); stats.into_object() } @@ -61,6 +66,38 @@ fn get_zone_session(py: Python) -> PyResult { ) } +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(PyList::new( + py, + v.iter() + .map(|s| s.into_py_object(py)) + .collect::>() + .as_slice(), + )) + }, + ) +} + +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(PyList::new( + py, + v.iter() + .map(|s| s.into_py_object(py)) + .collect::>() + .as_slice(), + )) + }, + ) +} + fn new_zone_session(_py: Python) -> PyResult { let meter = &mut METER.lock().unwrap(); @@ -69,6 +106,22 @@ fn new_zone_session(_py: Python) -> PyResult { 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, @@ -82,7 +135,6 @@ fn initialize(_py: Python) -> PyResult { 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 { @@ -116,15 +168,11 @@ fn register_message(events: &mut PlayerEvents, message: &game_protocol::Message) 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::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::Died(msg) => events.register_combat_leave(msg.source).unwrap_or(()), _ => {} } } @@ -133,11 +181,19 @@ 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, "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_zone_session", - py_fn!(py, get_zone_session()), + "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()))?; Ok(()) }); @@ -168,31 +224,101 @@ mod tests { register_message(meter, &message); } - pub fn get_player_in_zone_by_index(py: Python, index: usize) -> PyDict { + 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() + 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) - } + stats + .get_item(py, key) + .unwrap() + .cast_as::(py) + .unwrap() + .value(py) + } } trait Testing { fn new(source: usize) -> Self; } - impl Testing for message::NewCharacter { - 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: String::from("CH1"), + character_name: name.to_owned(), health: 10.0, max_health: 10.0, energy: 1.0, @@ -201,11 +327,11 @@ mod tests { } } - impl Testing for message::CharacterStats { - fn new(source: usize) -> Self { + impl NamedTesting for message::CharacterStats { + fn new_named(name: &str, source: usize) -> Self { Self { source: source, - character_name: String::from("MAIN_CH1"), + character_name: name.to_owned(), health: 10.0, max_health: 10.0, energy: 1.0, @@ -214,6 +340,24 @@ mod tests { } } + 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 { @@ -224,8 +368,8 @@ mod tests { } } - impl Testing for message::RegenerationHealthChanged { - fn new(source: usize) -> Self { + impl SwitchableTesting for message::RegenerationHealthChanged { + fn enabled(source: usize) -> Self { Self { source: source, health: 10.0, @@ -233,6 +377,15 @@ mod tests { regeneration_rate: Some(1.0), } } + + fn disabled(source: usize) -> Self { + Self { + source: source, + health: 10.0, + max_health: 10.0, + regeneration_rate: None, + } + } } #[test] @@ -261,7 +414,7 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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); @@ -269,6 +422,24 @@ mod tests { 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::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(); @@ -276,13 +447,13 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0); } @@ -293,18 +464,17 @@ mod tests { helpers::register(Message::NewCharacter(message::NewCharacter::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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_player_in_zone_by_index(py, 0); + let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0); assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0); } @@ -315,20 +485,215 @@ mod tests { helpers::register(Message::CharacterStats(message::CharacterStats::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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::HealthUpdate(message::HealthUpdate::new(1))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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_player_in_zone_by_index(py, 0); + 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::HealthUpdate(message::HealthUpdate::new(2))); - let stats = helpers::get_player_in_zone_by_index(py, 0); + 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::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::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::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 are out of combat + + let guard = helpers::init(); + let py = guard.python(); + + helpers::register(Message::CharacterStats(message::CharacterStats::new_named( + "1", 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::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::HealthUpdate(message::HealthUpdate::new(3))); + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::disabled(3), + )); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(1), + )); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "1").unwrap(), + "damage" + ), + 10.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "2").unwrap(), + "damage" + ), + 10.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "3").unwrap(), + "damage" + ), + 10.0 + ); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(2), + )); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "1").unwrap(), + "damage" + ), + 10.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "2").unwrap(), + "damage" + ), + 10.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "3").unwrap(), + "damage" + ), + 10.0 + ); + + helpers::register(Message::RegenerationHealthChanged( + message::RegenerationHealthChanged::enabled(3), + )); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "1").unwrap(), + "damage" + ), + 0.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "2").unwrap(), + "damage" + ), + 0.0 + ); + assert_eq!( + helpers::get_float( + py, + &helpers::get_player_last_fight_by_name(py, "3").unwrap(), + "damage" + ), + 0.0 + ); + } } diff --git a/src/meter/mod.rs b/src/meter/mod.rs index bdc6637..48220ce 100644 --- a/src/meter/mod.rs +++ b/src/meter/mod.rs @@ -15,13 +15,16 @@ use player::Player; pub use traits::*; pub use types::*; -#[derive(Hash, Eq, PartialEq, Clone)] +#[derive(Hash, Eq, PartialEq, Clone, Debug)] pub struct PlayerName(String); +#[derive(Debug)] pub struct Session { players: HashMap, } +type PlayerStatisticsVec = Vec; + impl Session { fn new() -> Self { Self { @@ -35,37 +38,50 @@ impl Session { players.insert(player_name.clone(), Player::new(player.id)); } - Self { - players - } + Self { players } } - pub fn stats(&self) -> Vec { + 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() + dps: player.dps(), }) .collect() } + pub fn cleanup_players(&mut self) { + let without_dmg = self + .players + .iter() + .filter(|(_, player)| player.damage() == 0.0) + .map(|(name, _)| name.clone()) + .collect::>(); + for w in without_dmg { + self.players.remove_entry(&w); + } + } + + pub fn players(&self) -> Vec<&Player> { + self.players.iter().map(|(_, p)| p).collect() + } + fn get_player_by_id(&mut self, player_id: usize) -> Option<&mut Player> { self.players.values_mut().find(|p| p.id == player_id) } fn add_player(&mut self, player_name: &str, player_id: usize) { - self.players.insert( - PlayerName(player_name.to_owned()), - Player::new(player_id), - ); + self.players + .insert(PlayerName(player_name.to_owned()), Player::new(player_id)); } } pub struct Meter { zone_sessions: VecDeque, + last_fight_session: Session, main_player_id: Option, } @@ -73,42 +89,50 @@ impl Meter { pub fn new() -> Self { Self { zone_sessions: VecDeque::new(), + last_fight_session: Session::new(), main_player_id: None, } } - #[allow(dead_code)] - pub fn reset(&mut self) { - self.zone_sessions = VecDeque::new(); - self.main_player_id = None; + fn add_player(&mut self, name: &str, id: usize) -> Option<()> { + let session = self.zone_sessions.back_mut()?; + session.add_player(name, id); + self.last_fight_session.add_player(name, id); + Some(()) + } + + fn new_session(&mut self) { + self.zone_sessions.push_back(Session::new()); + self.last_fight_session = Session::new(); } } - impl PlayerEvents for Meter { - fn get_player_in_zone(&mut self, player_id: usize) -> Option<&mut Player> { + fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option> { let session = self.zone_sessions.back_mut()?; - session.get_player_by_id(player_id) + let zone_player = session.get_player_by_id(player_id)?; + Some(vec![ + zone_player, + self.last_fight_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.zone_sessions.back_mut() { - Some(session) => session.add_player(name, id), - None => { - let mut session = Session::new(); - session.add_player(name, id); - self.zone_sessions.push_back(session); - } + + if self.zone_sessions.back().is_none() { + self.new_session(); } + self.add_player(name, id); } 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"); - self.zone_sessions.push_back(Session::new()); + self.zone_sessions.back_mut()?.cleanup_players(); + self.new_session(); } Some(()) @@ -117,11 +141,25 @@ impl PlayerEvents for Meter { fn register_player(&mut self, name: &str, id: usize) { if self.zone_sessions.is_empty() { debug!("New session"); - self.zone_sessions.push_back(Session::new()); + self.new_session(); } - let session = self.zone_sessions.back_mut().unwrap(); - session.add_player(name, id); + self.add_player(name, id); + } + fn register_combat_leave(&mut self, player_id: usize) -> Option<()> { + for player in self.get_damage_dealers_in_zone(player_id)? { + player.leave_combat(); + } + + if self + .last_fight_session + .players() + .iter() + .all(|p| p.combat_state() == CombatState::OutOfCombat) + { + self.last_fight_session = Session::from(&self.last_fight_session); + } + Some(()) } } @@ -138,6 +176,40 @@ impl ZoneStats for Meter { Some(()) } + + fn get_overall_session(&self) -> Option { + let all_stats = self.zone_sessions.iter().flat_map(|s| s.stats()).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); + acc + }, + ); + + Some(all_stats.iter().map(|(_, v)| v.clone()).collect()) + } + + fn reset(&mut self) { + self.zone_sessions = VecDeque::new(); + 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()) + } + + fn new_last_fight_session(&mut self) -> Option<()> { + self.last_fight_session = Session::from(&self.last_fight_session); + Some(()) + } } #[test] @@ -147,7 +219,9 @@ fn test_meter() { assert_eq!(meter.get_zone_session(), None); 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()); -} \ No newline at end of file + assert_eq!( + meter.get_zone_session().unwrap()[0].player, + "name".to_owned() + ); +} diff --git a/src/meter/player.rs b/src/meter/player.rs index e8ebcb3..533593f 100644 --- a/src/meter/player.rs +++ b/src/meter/player.rs @@ -1,33 +1,33 @@ +use std::fmt; use std::sync::{Arc, Mutex}; use timer; +use super::traits::CombatState; +use super::traits::DamageDealer; use super::traits::DamageStats; -#[derive(PartialEq)] -enum CombatState -{ - InCombat, - OutOfCombat -} - -struct Time -{ +struct Time { _guard: timer::Guard, - _timer: timer::Timer + _timer: timer::Timer, } -pub struct Player -{ +impl fmt::Debug for Time { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "") + } +} + +#[derive(Debug)] +pub struct Player { pub id: usize, damage_dealt: f32, time_elapsed: Arc>, combat_state: Arc>, - _time: Time + _time: Time, } -impl Player -{ +impl Player { pub fn new(id: usize) -> Self { let _timer = timer::Timer::new(); let time_elapsed = Arc::new(Mutex::new(0.0)); @@ -39,20 +39,21 @@ impl Player if *combat_state.lock().unwrap() == CombatState::InCombat { *time_elapsed.lock().unwrap() += 10.0; } - }) }; Self { - id, - damage_dealt: 0.0, - time_elapsed, + id, + damage_dealt: 0.0, + time_elapsed, combat_state, - _time: Time{_timer, _guard} + _time: Time { _timer, _guard }, } } - - pub fn register_damage_dealt(&mut self, damage_dealt: f32) { +} + +impl DamageDealer for Player { + fn register_damage_dealt(&mut self, damage_dealt: f32) { if *self.combat_state.lock().unwrap() == CombatState::OutOfCombat { *self.time_elapsed.lock().unwrap() += 1000.0; } @@ -60,21 +61,27 @@ impl Player self.damage_dealt += damage_dealt } - pub fn enter_combat(&mut self) { + fn enter_combat(&mut self) { *self.combat_state.lock().unwrap() = CombatState::InCombat; } - pub fn leave_combat(&mut self) { + fn leave_combat(&mut self) { *self.combat_state.lock().unwrap() = CombatState::OutOfCombat; } + + fn combat_state(&self) -> CombatState { + match *self.combat_state.lock().unwrap() { + CombatState::InCombat => CombatState::InCombat, + CombatState::OutOfCombat => CombatState::OutOfCombat, + } + } } impl DamageStats for Player { fn damage(&self) -> f32 { self.damage_dealt } - 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 index db6a6b2..6679188 100644 --- a/src/meter/traits.rs +++ b/src/meter/traits.rs @@ -1,5 +1,10 @@ use super::types::PlayerStatistics; -use super::Player; + +#[derive(Debug, PartialEq)] +pub enum CombatState { + InCombat, + OutOfCombat, +} pub trait DamageStats { fn damage(&self) -> f32; @@ -15,8 +20,18 @@ pub trait DamageStats { } } +pub trait DamageDealer { + fn register_damage_dealt(&mut self, damage_dealt: f32); + + fn enter_combat(&mut self); + + fn leave_combat(&mut self); + + fn combat_state(&self) -> CombatState; +} + pub trait PlayerEvents { - fn get_player_in_zone(&mut self, player_id: usize) -> Option<&mut Player>; + fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option>; fn register_main_player(&mut self, name: &str, id: usize); @@ -25,32 +40,40 @@ pub trait PlayerEvents { 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)); + for player in self.get_damage_dealers_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(); + for player in self.get_damage_dealers_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(); + for player in self.get_damage_dealers_in_zone(player_id)? { + player.leave_combat(); + } Some(()) } } pub trait ZoneStats { + fn reset(&mut self); + 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<()>; } diff --git a/src/meter/types.rs b/src/meter/types.rs index b6917db..61dcd5b 100644 --- a/src/meter/types.rs +++ b/src/meter/types.rs @@ -1,7 +1,18 @@ -#[derive(Debug, PartialEq)] +use super::traits::DamageStats; + +#[derive(Debug, PartialEq, Clone)] pub struct PlayerStatistics { pub player: String, pub damage: f32, pub time_in_combat: f32, - pub dps: f32 -} \ No newline at end of file + pub dps: f32, +} + +impl DamageStats for PlayerStatistics { + fn damage(&self) -> f32 { + self.damage + } + fn time_in_combat(&self) -> f32 { + self.time_in_combat + } +}