Code cleanup;

This commit is contained in:
Wiktor Mazur
2020-03-17 18:45:48 +01:00
parent de68e5a57c
commit b467ee679a
6 changed files with 1 additions and 723 deletions
+1 -8
View File
@@ -18,6 +18,7 @@ from .list_item import PlayerListItem, StandalonePlayerListItem, to_player_list_
from .visibility import Visibility from .visibility import Visibility
from .combat_state import CombatState from .combat_state import CombatState
@dataclass @dataclass
class CombatTime: class CombatTime:
entered_combat: Optional[float] = None entered_combat: Optional[float] = None
@@ -82,14 +83,6 @@ class Player(Stats):
return time_utils.as_milliseconds(self.damage_done / self.time_in_combat) 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): class DamageStats(CombatEventReceiver, Stats):
def __init__(self, players=None): def __init__(self, players=None):
-266
View File
@@ -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(())
}
}
-189
View File
@@ -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);
}
}
-77
View File
@@ -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));
}
}
-80
View File
@@ -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<()>;
}
-103
View File
@@ -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)
}
}