Code cleanup;
This commit is contained in:
@@ -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):
|
||||
|
||||
@@ -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<Session>,
|
||||
last_fight_session: Session,
|
||||
unconsumed_items: HashMap<usize, photon_messages::Items>,
|
||||
}
|
||||
|
||||
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<Vec<&mut Player>> {
|
||||
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<PlayerStatisticsVec> {
|
||||
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<PlayerStatisticsVec> {
|
||||
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<PlayerStatisticsVec> {
|
||||
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(())
|
||||
}
|
||||
}
|
||||
@@ -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<Instant>,
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -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<String, Player>,
|
||||
}
|
||||
|
||||
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<F>(&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));
|
||||
}
|
||||
}
|
||||
@@ -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<PlayerStatisticsVec>;
|
||||
fn reset_last_fight_stats(&mut self) -> Option<()>;
|
||||
}
|
||||
|
||||
pub trait ZoneStats {
|
||||
fn zone_stats(&self) -> Option<PlayerStatisticsVec>;
|
||||
fn reset_zone_stats(&mut self) -> Option<()>;
|
||||
}
|
||||
|
||||
pub trait OverallStats {
|
||||
fn overall_stats(&self) -> Option<PlayerStatisticsVec>;
|
||||
}
|
||||
|
||||
pub trait GameStats {
|
||||
fn reset_stats(&mut self) -> Option<()>;
|
||||
}
|
||||
@@ -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<PlayerStatistics>,
|
||||
}
|
||||
|
||||
#[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<PlayerStatistics>) -> Self {
|
||||
Self {
|
||||
_vec: player_statistics_vec,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn value(&self) -> Vec<PlayerStatistics> {
|
||||
self._vec.clone()
|
||||
}
|
||||
|
||||
pub fn merged(a: &Self, b: &Self) -> Self {
|
||||
let merged = [&a._vec[..], &b._vec[..]].concat().iter().fold(
|
||||
HashMap::<String, PlayerStatistics>::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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user