From b467ee679a95ea292bc2e123c5a8c2efc5dee67e Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Tue, 17 Mar 2020 18:45:48 +0100 Subject: [PATCH] Code cleanup; --- application/src/stats/damage_stats.py | 9 +- backend/src/meter/mod.rs | 266 -------------------------- backend/src/meter/player.rs | 189 ------------------ backend/src/meter/session.rs | 77 -------- backend/src/meter/traits.rs | 80 -------- backend/src/meter/types.rs | 103 ---------- 6 files changed, 1 insertion(+), 723 deletions(-) delete mode 100644 backend/src/meter/mod.rs delete mode 100644 backend/src/meter/player.rs delete mode 100644 backend/src/meter/session.rs delete mode 100644 backend/src/meter/traits.rs delete mode 100644 backend/src/meter/types.rs diff --git a/application/src/stats/damage_stats.py b/application/src/stats/damage_stats.py index 8ecf1e4..32e5422 100644 --- a/application/src/stats/damage_stats.py +++ b/application/src/stats/damage_stats.py @@ -18,6 +18,7 @@ from .list_item import PlayerListItem, StandalonePlayerListItem, to_player_list_ from .visibility import Visibility from .combat_state import CombatState + @dataclass class CombatTime: entered_combat: Optional[float] = None @@ -82,14 +83,6 @@ class Player(Stats): return time_utils.as_milliseconds(self.damage_done / self.time_in_combat) - def stats(self): - return { - 'player': self.name, - 'damage': self.damage_done, - 'time_in_combat': self.time_in_combat, - 'dps': self.dps, - 'items': self.items} - class DamageStats(CombatEventReceiver, Stats): def __init__(self, players=None): diff --git a/backend/src/meter/mod.rs b/backend/src/meter/mod.rs deleted file mode 100644 index e12ceb1..0000000 --- a/backend/src/meter/mod.rs +++ /dev/null @@ -1,266 +0,0 @@ -extern crate chrono; -extern crate timer; - -use std::collections::HashMap; - -use log::*; - -mod player; -mod traits; -mod types; -mod session; - -use crate::game::Event; -use player::Player; - -use super::photon_messages; -pub use traits::*; -pub use types::*; - -use session::Session; - -#[derive(Default)] -pub struct MeterConfig {} - -#[derive(Default)] -pub struct Meter { - zone_history: PlayerStatisticsVec, - zone_session: Option, - last_fight_session: Session, - unconsumed_items: HashMap, -} - -impl Meter { - pub fn new() -> Self { - Self { - ..Default::default() - } - } - - pub fn consume(&mut self, event: Event) -> Option<()> { - match event { - Event::MainPlayerAppeared(e) => { - let id = u32::from(e.id) as usize; - self.register_player(&e.name, id, true); - - if let Some(items) = self.unconsumed_items.get(&id) { - let i = items.clone(); - self.register_item_update(id, &i); - self.unconsumed_items.remove(&id); - } - }, - Event::PlayerAppeared(e) => { - let id = u32::from(e.id) as usize; - self.register_player(&e.name, id, false); - - if let Some(items) = self.unconsumed_items.get(&id) { - let i = items.clone(); - self.register_item_update(id, &i); - self.unconsumed_items.remove(&id); - } - }, - Event::ZoneChange => { - self.new_session(); - }, - Event::UpdateItems(e) => { - let player_id = u32::from(e.source) as usize; - let items = e.value; - let mut consumed = false; - for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) { - player.items_update(&items); - consumed = true; - } - - if !consumed { - info!("Storing not consumed items for player id: {}", player_id); - self.unconsumed_items.insert(player_id, items.clone()); - } - } - Event::DamageDone(e) => { - let player_id = u32::from(e.source) as usize; - for player in self.get_players_in_the_zone(player_id)? { - player.register_damage_dealt(f32::abs(e.value)); - } - } - Event::EnterCombat(e) => { - let player_id = u32::from(e.id) as usize; - if self.combat_state() == CombatState::OutOfCombat { - self.last_fight_session = Session::from(&self.last_fight_session); - } - for player in self.get_players_in_the_zone(player_id)? { - player.enter_combat(); - } - } - Event::LeaveCombat(e) => { - let player_id = u32::from(e.id) as usize; - for player in self.get_players_in_the_zone(player_id)? { - player.leave_combat(); - } - } - Event::UpdateFame(e) => { - let player_id = u32::from(e.source) as usize; - for player in self.get_players_in_the_zone(player_id)? { - player.register_fame_gain(e.value); - } - } - _ => {} - } - - Some(()) - } - - fn get_players_in_the_zone( - &mut self, - player_id: usize, - ) -> Option> { - 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]) - } - - fn register_player(&mut self, name: &str, id: usize, main: bool) { - if self.zone_session.is_none() { - info!( - "New player ({}) registered without session, creating new session", - name - ); - self.new_session(); - } - - if self - .get_players_in_the_zone(id) - .unwrap_or(vec![]) - .is_empty() - { - self.add_player(name, id, main); - } - } - - fn register_item_update( - &mut self, - player_id: usize, - items: &photon_messages::Items, - ) -> Option<()> { - let mut consumed = false; - for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) { - player.items_update(items); - consumed = true; - } - - if !consumed { - info!("Storing not consumed items for player id: {}", player_id); - self.unconsumed_items.insert(player_id, items.clone()); - } - - Some(()) - } - - fn stats_filter(&self, _player: &(&String, &Player)) -> bool { - true - } - - fn zone_session_mut(&mut self) -> Option<&mut Session> { - match &mut self.zone_session { - Some(s) => Some(s), - None => None, - } - } - - fn zone_session(&self) -> Option<&Session> { - match &self.zone_session { - Some(s) => Some(s), - 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, - } - } - - fn add_player(&mut self, name: &str, id: usize, main: bool) -> Option<()> { - let session = self.zone_session_mut()?; - session.add_player(name, id, main); - self.last_fight_session.add_player(name, id, main); - - Some(()) - } - - fn new_session(&mut self) { - if let Some(zone) = self.zone_session() { - 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(); - } - - fn combat_state(&self) -> CombatState { - if self - .last_fight_session - .players() - .iter() - .any(|p| p.combat_state() == CombatState::InCombat) - { - return CombatState::InCombat; - } - - CombatState::OutOfCombat - } -} - -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); - info!("Reset: last fight"); - Some(()) - } -} - -impl ZoneStats for Meter { - fn zone_stats(&self) -> Option { - let last_session = self.zone_session()?; - Some(last_session.stats(|p| self.stats_filter(p))) - } - - fn reset_zone_stats(&mut self) -> Option<()> { - let last_session = self.zone_session_mut()?; - self.zone_session = Some(Session::from(&last_session)); - info!("Reset: zone"); - Some(()) - } -} - -impl OverallStats for Meter { - fn overall_stats(&self) -> Option { - if let Some(zone) = self.zone_session() { - return Some(PlayerStatisticsVec::merged( - &self.zone_history, - &zone.stats(|p| self.stats_filter(p)), - )); - } - - None - } -} - -impl GameStats for Meter { - fn reset_stats(&mut self) -> Option<()> { - self.zone_history = PlayerStatisticsVec::new(); - let last_session = self.zone_session_mut()?; - self.zone_session = Some(Session::from(&last_session)); - self.last_fight_session = Session::from(&self.last_fight_session); - info!("Reset: overall"); - Some(()) - } -} diff --git a/backend/src/meter/player.rs b/backend/src/meter/player.rs deleted file mode 100644 index c54aac9..0000000 --- a/backend/src/meter/player.rs +++ /dev/null @@ -1,189 +0,0 @@ -#[cfg(test)] -use fake_clock::FakeClock as Instant; -#[cfg(not(test))] -use std::time::Instant; - -use super::photon_messages::Items; - -use super::traits::CombatState; -use super::traits::DamageDealer; -use super::traits::DamageStats; -use super::traits::FameGatherer; -use super::traits::FameStats; -use super::traits::ItemCarrier; - -#[derive(Debug)] -struct CombatTime { - entered_combat: Option, - time_in_combat: std::time::Duration, -} - -impl CombatTime { - fn new() -> Self { - Self { - entered_combat: None, - time_in_combat: std::time::Duration::from_millis(0), - } - } -} - -#[derive(Debug)] -struct Flags { - idle: bool, - main: bool, -} - -#[derive(Debug)] -pub struct Player { - id: usize, - damage_dealt: f32, - combat_time: CombatTime, - combat_state: CombatState, - time_started: Instant, - fame: f32, - items: Items, - flags: Flags, -} - -impl Player { - pub fn new(id: usize, main: bool) -> Self { - Self { - id, - damage_dealt: 0.0, - combat_time: CombatTime::new(), - combat_state: CombatState::OutOfCombat, - time_started: Instant::now(), - fame: 0.0, - items: Default::default(), - flags: Flags { idle: true, main }, - } - } - - pub fn from(other: &Self) -> Self { - Self { - id: other.id, - damage_dealt: 0.0, - combat_time: CombatTime::new(), - combat_state: other.combat_state(), - time_started: Instant::now(), - fame: 0.0, - items: other.items.clone(), - flags: Flags { - idle: true, - main: other.main(), - }, - } - } - - pub fn idle(&self) -> bool { - self.flags.idle - } - - pub fn id(&self) -> usize { - self.id - } - - pub fn main(&self) -> bool { - self.flags.main - } -} - -impl DamageDealer for Player { - fn register_damage_dealt(&mut self, damage_dealt: f32) { - if self.combat_state == CombatState::OutOfCombat { - return; - } - self.flags.idle = false; - self.damage_dealt += damage_dealt - } - - fn enter_combat(&mut self) { - self.flags.idle = false; - self.combat_time.entered_combat = Some(Instant::now()); - self.combat_state = CombatState::InCombat; - } - - fn leave_combat(&mut self) { - if let Some(entered_combat) = self.combat_time.entered_combat { - self.combat_time.time_in_combat += Instant::now() - entered_combat; - } - self.combat_state = CombatState::OutOfCombat; - } - - fn combat_state(&self) -> CombatState { - match self.combat_state { - 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 { - if self.combat_state == CombatState::InCombat { - if let Some(entered_combat) = self.combat_time.entered_combat { - let time_in_combat = - self.combat_time.time_in_combat + (Instant::now() - entered_combat); - return time_in_combat.as_millis() as f32; - } - } else { - return self.combat_time.time_in_combat.as_millis() as f32; - } - return 0.0; - } -} - -impl FameGatherer for Player { - fn register_fame_gain(&mut self, fame: f32) { - self.fame += fame; - self.flags.idle = false; - } -} - -impl ItemCarrier for Player { - fn items_update(&mut self, items: &Items) { - self.items = items.clone(); - self.flags.idle = false; - } - - fn items(&self) -> Items { - self.items.clone() - } -} - -impl FameStats for Player { - fn fame(&self) -> f32 { - self.fame - } - - fn time_started(&self) -> Instant { - self.time_started - } -} - -#[cfg(test)] -mod test { - use super::*; - - fn sleep(time: u64) { - use fake_clock::FakeClock; - FakeClock::advance_time(time); - } - - #[test] - fn test_player_fame_stats() { - let mut player = Player::new(1, true); - - sleep(1000 * 60); - player.register_fame_gain(100.0); - assert_eq!(player.fame_per_minute(), 100); - assert_eq!(player.fame_per_hour(), 5999); - - sleep(1000 * 60 * 60 - 1000 * 60); - - assert_eq!(player.fame_per_hour(), 100); - } -} diff --git a/backend/src/meter/session.rs b/backend/src/meter/session.rs deleted file mode 100644 index cca9044..0000000 --- a/backend/src/meter/session.rs +++ /dev/null @@ -1,77 +0,0 @@ -use std::collections::HashMap; - - -use crate::meter::traits::FameStats; -use crate::meter::traits::DamageStats; -use crate::meter::traits::ItemCarrier; -use crate::meter::traits::DamageDealer; -use crate::meter::types::PlayerStatistics; - -use super::player::Player; - -use super::traits::CombatState; -use super::types::PlayerStatisticsVec; - -#[derive(Debug, Default)] -pub struct Session { - players: HashMap, -} - -impl Session { - pub fn new() -> Self { - Self { - players: HashMap::new(), - } - } - - pub fn from(session: &Self) -> Self { - let mut players = HashMap::new(); - for (player_name, player) in &session.players { - let mut new_player = Player::from(player); - if let CombatState::InCombat = player.combat_state() { - new_player.enter_combat(); - } - players.insert(player_name.clone(), new_player); - } - - Self { players } - } - - 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(), - seconds_in_game: player.time_in_game().as_secs() as f32, - fame: player.fame(), - fame_per_minute: player.fame_per_minute(), - fame_per_hour: player.fame_per_hour(), - items: player.items(), - idle: player.idle(), - main_player_stats: player.main(), - }) - .collect(), - ) - } - - pub fn players(&self) -> Vec<&Player> { - self.players.iter().map(|(_, p)| p).collect() - } - - pub fn get_player_by_id(&mut self, player_id: usize) -> Option<&mut Player> { - self.players.values_mut().find(|p| p.id() == player_id) - } - - pub fn add_player(&mut self, player_name: &str, player_id: usize, main: bool) { - self.players - .insert(player_name.to_owned(), Player::new(player_id, main)); - } -} \ No newline at end of file diff --git a/backend/src/meter/traits.rs b/backend/src/meter/traits.rs deleted file mode 100644 index a1044db..0000000 --- a/backend/src/meter/traits.rs +++ /dev/null @@ -1,80 +0,0 @@ -#[cfg(test)] -use fake_clock::FakeClock as Instant; -#[cfg(not(test))] -use std::time::Instant; - -use super::types::PlayerStatisticsVec; -use super::photon_messages::Items; - -#[derive(Debug, PartialEq)] -pub enum CombatState { - InCombat, - OutOfCombat, -} - -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 FameStats { - fn fame(&self) -> f32; - fn time_started(&self) -> Instant; - fn time_in_game(&self) -> std::time::Duration { - Instant::now() - self.time_started() - } - fn fame_per_minute(&self) -> u32 { - let minutes_in_game = self.time_in_game().as_secs() as f32 / 60.0; - (self.fame() / minutes_in_game) as u32 - } - fn fame_per_hour(&self) -> u32 { - let hours_in_game = self.time_in_game().as_secs() as f32 / 60.0 / 60.0; - (self.fame() / hours_in_game) as u32 - } -} - -pub trait FameGatherer { - fn register_fame_gain(&mut self, fame: f32); -} - -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 ItemCarrier { - fn items_update(&mut self, items: &Items); - fn items(&self) -> Items; -} - -pub trait LastFightStats { - fn last_fight_stats(&self) -> Option; - fn reset_last_fight_stats(&mut self) -> Option<()>; -} - -pub trait ZoneStats { - fn zone_stats(&self) -> Option; - fn reset_zone_stats(&mut self) -> Option<()>; -} - -pub trait OverallStats { - fn overall_stats(&self) -> Option; -} - -pub trait GameStats { - fn reset_stats(&mut self) -> Option<()>; -} diff --git a/backend/src/meter/types.rs b/backend/src/meter/types.rs deleted file mode 100644 index ce68980..0000000 --- a/backend/src/meter/types.rs +++ /dev/null @@ -1,103 +0,0 @@ -use std::collections::HashMap; - -#[cfg(test)] -use fake_clock::FakeClock as Instant; -#[cfg(not(test))] -use std::time::Instant; - -use super::photon_messages::Items; -use super::traits::DamageStats; -use super::traits::FameStats; - -#[derive(Debug, PartialEq, Clone)] -pub struct PlayerStatistics { - pub player: String, - pub damage: f32, - pub time_in_combat: f32, - pub dps: f32, - pub seconds_in_game: f32, - pub fame: f32, - pub fame_per_minute: u32, - pub fame_per_hour: u32, - pub items: Items, - pub idle: bool, - pub main_player_stats: bool, -} - -#[derive(Debug, PartialEq, Clone, Default)] -pub struct PlayerStatisticsVec { - _vec: Vec, -} - -#[derive(Debug, PartialEq, Copy, Clone)] -pub enum StatType { - LastFight, - Zone, - Overall, - Unknown, -} - -impl PlayerStatisticsVec { - pub fn new() -> Self { - Self { _vec: vec![] } - } - - pub fn from(player_statistics_vec: Vec) -> Self { - Self { - _vec: player_statistics_vec, - } - } - - pub fn value(&self) -> Vec { - self._vec.clone() - } - - 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(); - s.seconds_in_game += stat.seconds_in_game; - s.fame += stat.fame; - s.fame_per_minute = s.fame_per_minute(); - s.fame_per_hour = s.fame_per_hour(); - s.main_player_stats = stat.main_player_stats; - s.items = stat.items.clone(); - }) - .or_insert(stat.clone()); - acc - }, - ); - - Self { - _vec: merged.iter().map(|(_, v)| v.clone()).collect(), - } - } -} - -impl DamageStats for PlayerStatistics { - fn damage(&self) -> f32 { - self.damage - } - fn time_in_combat(&self) -> f32 { - self.time_in_combat - } -} - -impl FameStats for PlayerStatistics { - fn fame(&self) -> f32 { - self.fame - } - - fn time_started(&self) -> Instant { - Instant::now() - } - - fn time_in_game(&self) -> std::time::Duration { - std::time::Duration::from_secs(self.seconds_in_game as u64) - } -}