+ fame statistics

This commit is contained in:
Wiktor Mazur
2019-09-28 23:18:07 +02:00
parent 9cd00e236f
commit 3a465e49c9
12 changed files with 278 additions and 21 deletions
+53 -1
View File
@@ -143,6 +143,9 @@ fn register_message(events: &mut meter::Meter, message: &game_protocol::Message)
game_protocol::Message::PartyDisbanded(_) => {
events.register_party_disbanded().unwrap_or(())
}
game_protocol::Message::FameUpdate(msg) => {
events.register_fame_gain(msg.source, msg.fame).unwrap_or(())
}
_ => {}
}
}
@@ -150,6 +153,8 @@ fn register_message(events: &mut meter::Meter, message: &game_protocol::Message)
#[cfg(test)]
mod tests {
use super::*;
use fake_clock::FakeClock as Instant;
use cpython::{PyClone, PyDict, PyFloat, PyUnicode};
use game_protocol::message;
@@ -167,6 +172,11 @@ mod tests {
Python::acquire_gil()
}
pub fn sleep(time: u64) {
use fake_clock::FakeClock;
FakeClock::advance_time(time);
}
pub fn register(message: Message) {
let meter = &mut METER.lock().unwrap();
r(meter, &message);
@@ -256,6 +266,15 @@ mod tests {
.unwrap()
.value(py)
}
pub fn get_number(py: Python, stats: &PyDict, key: &str) -> u32 {
stats
.get_item(py, key)
.unwrap()
.extract(py)
.unwrap()
}
}
trait Testing {
@@ -329,6 +348,15 @@ mod tests {
}
}
impl Testing for message::FameUpdate {
fn new(source: usize) -> Self {
Self {
source: source,
fame: 100.0,
}
}
}
impl SwitchableTesting for message::RegenerationHealthChanged {
fn enabled(source: usize) -> Self {
Self {
@@ -400,11 +428,15 @@ mod tests {
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(stats.len(py), 4);
assert_eq!(stats.len(py), 8);
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
assert_eq!(helpers::get_float(py, &stats, "time_in_combat"), 0.0);
assert_eq!(helpers::get_float(py, &stats, "dps"), 0.0);
assert_eq!(helpers::get_float(py, &stats, "seconds_in_game"), 0.0);
assert_eq!(helpers::get_float(py, &stats, "fame"), 0.0);
assert_eq!(helpers::get_number(py, &stats, "fame_per_minute"), 0);
assert_eq!(helpers::get_number(py, &stats, "fame_per_hour"), 0);
}
#[test]
@@ -719,4 +751,24 @@ mod tests {
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_none());
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none());
}
#[test]
fn test_fame_statistics() {
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_number(py, &stats, "fame_per_minute"), 0);
helpers::sleep(1000 * 60);
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_number(py, &stats, "fame_per_minute"), 0);
helpers::register(Message::FameUpdate(message::FameUpdate::new(1)));
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_number(py, &stats, "fame_per_minute"), 100);
}
}
+18
View File
@@ -291,9 +291,26 @@ impl PartyDisbanded {
}
}
#[derive(Debug)]
pub struct FameUpdate {
pub source: usize,
pub fame: f32
}
impl FameUpdate {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "FameUpdate::source")?;
let raw_fame = deserialize_number!(val, 2, "FameUpdate::fame")?;
let fame = raw_fame as f32 / 10000.0;
Some(Message::FameUpdate(FameUpdate{source, fame}))
}
}
#[derive(Debug)]
pub enum Message {
FameUpdate(FameUpdate),
Leave(Leave),
ChatSay(ChatSay),
NewCharacter(NewCharacter),
@@ -318,6 +335,7 @@ impl Packet {
210 => PartyNew::encode(self.parameters),
112 => PartyJoin::encode(self.parameters),
211 => PartyDisbanded::encode(self.parameters),
71 => FameUpdate::encode(self.parameters),
1001 => CharacterStats::encode(self.parameters),
_ => None,
}
+16
View File
@@ -48,6 +48,10 @@ impl Session {
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(),
})
.collect(),
)
@@ -182,6 +186,18 @@ impl PlayerEvents for Meter {
Some(vec![zone_player, las_fight_session_player])
}
fn get_fame_gatherers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn FameGatherer>> {
let main_player_id = self.main_player_id?;
let (zone, last_fight) = self.sessions_mut()?;
if player_id != main_player_id {
return None;
}
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_main_player(&mut self, name: &str, id: usize) {
debug!("Main player {} registerd with id {}", name, id);
self.main_player_id = Some(id);
+52
View File
@@ -1,11 +1,18 @@
use std::fmt;
use std::sync::{Arc, Mutex};
#[cfg(test)]
use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use timer;
use super::traits::CombatState;
use super::traits::DamageDealer;
use super::traits::DamageStats;
use super::traits::FameStats;
use super::traits::FameGatherer;
struct Time {
_guard: timer::Guard,
@@ -41,6 +48,8 @@ pub struct Player {
time_elapsed: Arc<Mutex<f32>>,
combat_state: Arc<Mutex<CombatState>>,
_time: Option<Time>,
time_started: Instant,
fame: f32
}
@@ -55,6 +64,8 @@ impl Player {
time_elapsed,
combat_state,
_time: None,
time_started: Instant::now(),
fame: 0.0
}
}
}
@@ -97,3 +108,44 @@ impl DamageStats for Player {
*self.time_elapsed.lock().unwrap()
}
}
impl FameGatherer for Player {
fn register_fame_gain(&mut self, fame: f32) {
self.fame += fame;
}
}
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);
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);
}
}
+36 -1
View File
@@ -1,3 +1,8 @@
#[cfg(test)]
use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use super::types::PlayerStatisticsVec;
#[derive(Debug, PartialEq)]
@@ -20,6 +25,26 @@ pub trait DamageStats {
}
}
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);
@@ -31,7 +56,9 @@ pub trait DamageDealer {
}
pub trait PlayerEvents {
fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut DamageDealer>>;
fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn DamageDealer>>;
fn get_fame_gatherers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn FameGatherer>>;
fn register_main_player(&mut self, name: &str, id: usize);
@@ -39,6 +66,14 @@ pub trait PlayerEvents {
fn register_player(&mut self, name: &str, id: usize);
fn register_fame_gain(&mut self, player_id: usize, fame: f32) -> Option<()> {
for player in self.get_fame_gatherers_in_zone(player_id)? {
player.register_fame_gain(fame);
}
Some(())
}
fn register_damage_dealt(&mut self, player_id: usize, damage: f32) -> Option<()> {
for player in self.get_damage_dealers_in_zone(player_id)? {
if damage < 0.0 {
+39
View File
@@ -1,5 +1,10 @@
use std::collections::HashMap;
#[cfg(test)]
use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use cpython::PythonObject;
use cpython::ToPyObject;
use cpython::Python;
@@ -8,6 +13,7 @@ use cpython::PyDict;
use cpython::PyList;
use super::traits::DamageStats;
use super::traits::FameStats;
#[derive(Debug, PartialEq, Clone)]
pub struct Party {
@@ -38,6 +44,10 @@ pub struct PlayerStatistics {
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
}
#[derive(Debug, PartialEq, Clone)]
@@ -67,6 +77,10 @@ impl PlayerStatisticsVec {
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();
})
.or_insert(stat.clone());
acc
@@ -88,6 +102,19 @@ impl DamageStats for PlayerStatistics {
}
}
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)
}
}
impl ToPyObject for PlayerStatistics {
type ObjectType = PyObject;
@@ -106,6 +133,18 @@ impl ToPyObject for PlayerStatistics {
stats
.set_item(py, "dps", self.dps.to_py_object(py))
.unwrap();
stats
.set_item(py, "seconds_in_game", self.seconds_in_game.to_py_object(py))
.unwrap();
stats
.set_item(py, "fame", self.fame.to_py_object(py))
.unwrap();
stats
.set_item(py, "fame_per_minute", self.fame_per_minute.to_py_object(py))
.unwrap();
stats
.set_item(py, "fame_per_hour", self.fame_per_hour.to_py_object(py))
.unwrap();
stats.into_object()
}