Repository cleanup

This commit is contained in:
Wiktor Mazur
2019-10-20 14:59:45 +02:00
parent a15f7ae92c
commit e14dbf66dc
36 changed files with 180 additions and 102 deletions
-702
View File
@@ -1,702 +0,0 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use crate::game_protocol;
use crate::meter;
pub use meter::GameStats;
pub use meter::LastFightStats;
pub use meter::OverallStats;
pub use meter::PartyEvents;
pub use meter::PlayerEvents;
pub use meter::ZoneStats;
pub use meter::MeterConfig;
pub use meter::PlayerStatistics;
pub use meter::PlayerStatisticsVec;
pub use meter::StatType;
lazy_static! {
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new());
}
pub fn stats(meter: &meter::Meter, stat_type: StatType) -> Vec<meter::PlayerStatistics> {
match stat_type {
StatType::Zone => meter
.zone_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
StatType::LastFight => meter
.last_fight_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
StatType::Overall => meter
.overall_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
_ => vec![],
}
}
pub fn reset(meter: &mut meter::Meter, stat_type: StatType) {
match stat_type {
StatType::Zone => {
meter.reset_zone_stats();
}
StatType::LastFight => {
meter.reset_last_fight_stats();
}
StatType::Overall => {
meter.reset_stats();
}
_ => error!("Unexpected stat to reset."),
}
}
pub fn get_players_in_party(meter: &meter::Meter) -> Vec<String> {
meter.get_players_in_party().unwrap_or(vec![])
}
pub fn initialize() -> Arc<Mutex<meter::Meter>> {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Info,
Config::default(),
File::create("damage-meter.log").unwrap(),
)])
.unwrap();
let meter = meter::Meter::new();
let meter = Arc::new(Mutex::new(meter));
let cloned_meter = meter.clone();
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
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 {
continue;
}
let meter = &mut cloned_meter.lock().unwrap();
if let Some(messages) = game_protocol::decode(&packet.payload) {
register_messages(meter, &messages);
}
}
}
});
meter
}
fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_protocol::Message>) {
messages
.iter()
.for_each(|message| register_message(meter, &message));
}
fn register_message(events: &mut meter::Meter, message: &game_protocol::Message) {
info!("Found message {:?}", message);
match message {
game_protocol::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()),
game_protocol::Message::NewCharacter(msg) => {
events.register_player(&msg.character_name, msg.source)
}
game_protocol::Message::CharacterStats(msg) => {
events.register_main_player(&msg.character_name, msg.source)
}
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::Died(msg) => events.register_combat_leave(msg.source).unwrap_or(()),
game_protocol::Message::PartyNew(msg) => events
.register_new_party(&msg.players, msg.source)
.unwrap_or(()),
game_protocol::Message::PartyJoin(msg) => {
events.register_new_member(&msg.target_name).unwrap_or(())
}
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(()),
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use game_protocol::message;
use game_protocol::Message;
mod helpers {
use super::*;
pub fn init_() -> meter::Meter {
meter::Meter::new()
}
pub fn sleep(time: u64) {
use fake_clock::FakeClock;
FakeClock::advance_time(time);
}
}
trait Testing {
fn new(source: usize) -> Self;
}
trait NamedTesting {
fn new_named(name: &str, source: usize) -> Self;
}
trait ListNamedTesting {
fn new_list_of_named(names: &[&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: name.to_owned(),
health: 10.0,
max_health: 10.0,
energy: 1.0,
max_energy: 1.0,
}
}
}
impl NamedTesting for message::CharacterStats {
fn new_named(name: &str, source: usize) -> Self {
Self {
source: source,
character_name: name.to_owned(),
health: 10.0,
max_health: 10.0,
energy: 1.0,
max_energy: 1.0,
}
}
}
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 {
source: 200,
target: source,
value: -10.0,
}
}
}
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 {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: Some(1.0),
}
}
fn disabled(source: usize) -> Self {
Self {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: None,
}
}
}
impl ListNamedTesting for message::PartyNew {
fn new_list_of_named(names: &[&str], source: usize) -> Self {
Self {
source: source,
players: names.iter().map(ToString::to_string).collect(),
}
}
}
impl NamedTesting for message::PartyJoin {
fn new_named(name: &str, source: usize) -> Self {
Self {
target_name: name.to_string(),
source,
}
}
}
impl Testing for message::PartyDisbanded {
fn new(source: usize) -> Self {
Self { source }
}
}
#[test]
fn test_empty_session() {
let meter = helpers::init_();
assert_eq!(stats(&meter, StatType::Zone).len(), 0);
}
#[test]
fn test_new_player_appears() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)),
);
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
}
#[test]
fn test_new_player_stats() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)),
);
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].player, "CH1");
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].time_in_combat, 0.0);
assert_eq!(zone_stats[0].dps, 0.0);
assert_eq!(zone_stats[0].seconds_in_game, 0.0);
assert_eq!(zone_stats[0].fame, 0.0);
assert_eq!(zone_stats[0].fame_per_minute, 0);
assert_eq!(zone_stats[0].fame_per_hour, 0);
}
#[test]
fn test_damage_aggregation() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 20.0);
}
#[test]
fn test_new_player_damage() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
}
#[test]
fn test_new_player_damage_reset() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(message::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
reset(&mut meter, StatType::Zone);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
}
#[test]
fn test_zone_detection() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::CharacterStats(message::CharacterStats::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "MAIN_CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(&mut meter, &Message::Leave(message::Leave::new(1)));
register_message(
&mut meter,
&Message::CharacterStats(message::CharacterStats::new(2)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled(2)),
);
register_message(
&mut meter,
&Message::HealthUpdate(message::HealthUpdate::new(2)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
}
macro_rules! main_character_enters {
($meter:expr, $name:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::CharacterStats(message::CharacterStats::new_named($name, $id)),
);
};
}
macro_rules! character_enters {
($meter:expr, $name:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::NewCharacter(message::NewCharacter::new_named($name, $id)),
);
};
}
macro_rules! attack {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::disabled($id)),
);
register_message(
&mut $meter,
&Message::HealthUpdate(message::HealthUpdate::new($id)),
);
};
}
macro_rules! combat_leave {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(message::RegenerationHealthChanged::enabled($id)),
);
};
}
#[test]
fn test_two_players_in_the_zone() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
character_enters!(meter, "CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
register_message(&mut meter, &Message::Leave(message::Leave::new(1)));
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
}
#[test]
fn test_overall_damage() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 20.0);
}
#[test]
fn test_last_fight_damage() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
}
#[test]
fn test_last_fight_management() {
// session should be started when first player attacks
// damage should be 0 when all players were out of combat and some player attacks
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 2);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH2", 3);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 2);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
attack!(meter, 1);
combat_leave!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 0.0);
}
macro_rules! new_party {
($meter:expr, $members:expr, $party_id:expr) => {
register_message(
&mut $meter,
&Message::PartyNew(message::PartyNew::new_list_of_named($members, $party_id))
);
};
}
macro_rules! new_party_member {
($meter:expr, $player:expr, $party_id:expr) => {
register_message(
&mut $meter,
&Message::PartyJoin(message::PartyJoin::new_named($player, $party_id))
);
};
}
#[test]
fn test_party_members() {
let mut meter = helpers::init_();
meter.configure(meter::MeterConfig {
skip_non_party_members: true,
..Default::default()
});
main_character_enters!(meter, "MAIN_CH1", 1);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "MAIN_CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
new_party!(meter, &["MAIN_CH1", "CH1"], 1);
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "MAIN_CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_some());
character_enters!(meter, "CH2", 3);
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "MAIN_CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH2").is_none());
new_party_member!(meter, "CH2", 1);
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "MAIN_CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH2").is_some());
register_message(&mut meter, &Message::PartyDisbanded(message::PartyDisbanded::new(1)));
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "MAIN_CH1").is_some());
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
assert!(zone_stats.iter().find(|s| s.player == "CH2").is_none());
}
#[test]
fn test_fame_statistics() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 0);
helpers::sleep(1000 * 60);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 0);
register_message(&mut meter, &Message::FameUpdate(message::FameUpdate::new(1)));
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 100);
}
}
-343
View File
@@ -1,343 +0,0 @@
use log::*;
use super::packet::Packet;
use photon_protocol::Parameters;
use photon_protocol::Value;
macro_rules! deserialize_number {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::Short(v) => Some(*v as usize),
Value::Integer(v) => Some(*v as usize),
Value::Byte(v) => Some(*v as usize),
_ => {
error!("Failed to deserialize {}", $name);
None
}
}
} else {
error!("Index {} not found in {}", $index, $name);
None
}
};
}
macro_rules! deserialize_string {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::String(v) => Some(v.clone()),
_ => {
error!("Failed to deserialize {}", $name);
None
}
}
} else {
None
}
};
}
macro_rules! deserialize_string_vec {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::Array(arr) => {
let mut ret = vec![];
for v in arr {
if let Value::String(s) = v {
ret.push(s.clone());
}
}
Some(ret)
},
_ => {
error!("Failed to deserialize {}", $name);
None
}
}
} else {
None
}
};
}
macro_rules! deserialize_float {
($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) {
match p {
Value::Float(v) => Some(*v as f32),
_ => {
error!("Failed to deserialize {}", $name);
None
}
}
} else {
None
}
};
}
#[derive(Debug)]
pub struct ChatSay {
pub source: usize,
pub source_name: String,
pub text: String,
}
impl ChatSay {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "ChatSay::source")?;
let source_name = deserialize_string!(val, 1, "ChatSay::source_name")?;
let text = deserialize_string!(val, 2, "ChatSay::text")?;
Some(Message::ChatSay(Self {
source,
source_name,
text,
}))
}
}
#[derive(Debug)]
pub struct NewCharacter {
pub source: usize,
pub character_name: String,
pub health: f32,
pub max_health: f32,
pub energy: f32,
pub max_energy: f32,
}
impl NewCharacter {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "NewCharacter::source")?;
let character_name = deserialize_string!(val, 1, "NewCharacter::character_name")?;
let health = deserialize_float!(val, 18, "NewCharacter::health")?;
let max_health = deserialize_float!(val, 19, "NewCharacter::max_health")?;
let energy = deserialize_float!(val, 22, "NewCharacter::energy")?;
let max_energy = deserialize_float!(val, 23, "NewCharacter::max_energy")?;
Some(Message::NewCharacter(Self {
source,
character_name,
health,
max_health,
energy,
max_energy,
}))
}
}
#[derive(Debug)]
pub struct HealthUpdate {
pub source: usize,
pub target: usize,
pub value: f32,
}
impl HealthUpdate {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "HealthUpdate::source")?;
let target = deserialize_number!(val, 6, "HealthUpdate::target")?;
let value = deserialize_float!(val, 2, "HealthUpdate::value")?;
Some(Message::HealthUpdate(Self {
source,
target,
value,
}))
}
}
#[derive(Debug)]
pub struct RegenerationHealthChanged {
pub source: usize,
pub health: f32,
pub max_health: f32,
pub regeneration_rate: Option<f32>,
}
impl RegenerationHealthChanged {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "RegenerationHealthChanged::source")?;
let health = deserialize_float!(val, 2, "RegenerationHealthChanged::health")?;
let max_health = deserialize_float!(val, 3, "RegenerationHealthChanged::max_health")?;
let regeneration_rate = deserialize_float!(val, 4, "RegenerationHealthChanged::regeneration_rate");
Some(Message::RegenerationHealthChanged(Self {
source,
health,
max_health,
regeneration_rate,
}))
}
}
#[derive(Debug)]
pub struct CharacterStats {
pub source: usize,
pub character_name: String,
pub health: f32,
pub max_health: f32,
pub energy: f32,
pub max_energy: f32,
}
impl CharacterStats {
fn encode(val: Parameters) -> Option<Message> {
if val.len() < 40 {
return None;
}
let source = deserialize_number!(val, 0, "CharacterStats::source")?;
let character_name = deserialize_string!(val, 2, "CharacterStats::character_name")?;
let health = deserialize_float!(val, 11, "CharacterStats::health")?;
let max_health = deserialize_float!(val, 12, "CharacterStats::max_health")?;
let energy = deserialize_float!(val, 15, "CharacterStats::energy")?;
let max_energy = deserialize_float!(val, 16, "CharacterStats::max_energy")?;
Some(Message::CharacterStats(Self {
source,
character_name,
health,
max_health,
energy,
max_energy,
}))
}
}
#[derive(Debug)]
pub struct Leave {
pub source: usize
}
impl Leave {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "Leave::source")?;
Some(Message::Leave(Leave{source}))
}
}
#[derive(Debug)]
pub struct Died {
pub source: usize,
pub target: usize,
pub target_name: String
}
impl Died {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "Died::source")?;
let target = deserialize_number!(val, 1, "Died::target")?;
let target_name = deserialize_string!(val, 3, "Died::target_name")?;
Some(Message::Died(Died{source, target, target_name}))
}
}
#[derive(Debug)]
pub struct PartyNew {
pub source: usize,
pub players: Vec<String>,
}
impl PartyNew {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "PartyNew::source")?;
let players = deserialize_string_vec!(val, 5, "PartyNew::players")?;
Some(Message::PartyNew(PartyNew{source, players}))
}
}
#[derive(Debug)]
pub struct PartyJoin {
pub source: usize,
pub target_name: String
}
impl PartyJoin {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 0, "PartyJoin::source")?;
let target_name = deserialize_string!(val, 2, "PartyJoin::target_name")?;
Some(Message::PartyJoin(PartyJoin{source, target_name}))
}
}
#[derive(Debug)]
pub struct PartyDisbanded {
pub source: usize,
}
impl PartyDisbanded {
fn encode(val: Parameters) -> Option<Message> {
let source = deserialize_number!(val, 1, "PartyDisbanded::source")?;
Some(Message::PartyDisbanded(PartyDisbanded{source}))
}
}
#[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),
HealthUpdate(HealthUpdate),
RegenerationHealthChanged(RegenerationHealthChanged),
CharacterStats(CharacterStats),
Died(Died),
PartyNew(PartyNew),
PartyJoin(PartyJoin),
PartyDisbanded(PartyDisbanded)
}
impl Packet {
pub fn decode(self) -> Option<Message> {
match self.code {
1 => Leave::encode(self.parameters),
6 => HealthUpdate::encode(self.parameters),
24 => NewCharacter::encode(self.parameters),
63 => ChatSay::encode(self.parameters),
79 => RegenerationHealthChanged::encode(self.parameters),
149 => Died::encode(self.parameters),
210 => PartyNew::encode(self.parameters),
212 => PartyJoin::encode(self.parameters),
211 => PartyDisbanded::encode(self.parameters),
71 => FameUpdate::encode(self.parameters),
1001 => CharacterStats::encode(self.parameters),
_ => None,
}
}
}
-6
View File
@@ -1,6 +0,0 @@
mod packet;
mod protocol;
pub mod message;
pub use protocol::decode;
pub use message::Message;
-7
View File
@@ -1,7 +0,0 @@
use photon_protocol::Parameters;
#[derive(Debug)]
pub struct Packet {
pub code: usize,
pub parameters: Parameters
}
-103
View File
@@ -1,103 +0,0 @@
use std::io::Cursor;
use bytes::Buf;
use log::*;
static CMD_HEADER_LENGTH: u32 = 12;
static SIGNIFIER_BYTE_LENGTH: usize = 1;
static LOG_OUT: u8 = 4;
static SEND_UNRELIABLE: u8 = 7;
static SEND_RELIABLE: u8 = 6;
static REQUEST_CONSTANT: usize = 10000;
static RESPONSE_CONSTANT: usize = 1000;
static MSG_TYPE_REQUEST: u8 = 2;
static MSG_TYPE_RESPONSE: u8 = 3;
static MSG_TYPE_EVENT: u8 = 4;
use super::message::Message;
use super::packet::Packet;
pub fn decode(payload: &[u8]) -> Option<Vec<Message>>
{
let mut messages = vec![];
let mut cursor = Cursor::new(payload);
cursor.advance(3);
let cmd_cnt = photon_protocol::deserialize_byte(&mut cursor)?;
cursor.advance(8);
for _ in 0..cmd_cnt {
let cmd_type = photon_protocol::deserialize_byte(&mut cursor)?;
cursor.advance(3);
let cmd_length = photon_protocol::deserialize_integer(&mut cursor)?;
cursor.advance(4);
if cmd_type == LOG_OUT {
break;
} else if cmd_type == SEND_UNRELIABLE {
cursor.advance(4);
if let Some(msg) = on_message(&mut cursor, cmd_length - 4) {
messages.push(msg);
}
} else if cmd_type == SEND_RELIABLE {
if let Some(msg) = on_message(&mut cursor, cmd_length) {
messages.push(msg);
}
} else {
cursor.advance((cmd_length - CMD_HEADER_LENGTH) as usize);
}
}
Some(messages)
}
fn on_message(cursor: &mut Cursor<&[u8]>, msg_len: u32) -> Option<Message> {
let mut message = None;
let init = cursor.bytes().len();
cursor.advance(SIGNIFIER_BYTE_LENGTH);
let msg_type = photon_protocol::deserialize_byte(cursor)?;
let operation_length = msg_len - CMD_HEADER_LENGTH - 2;
let mut payload = Cursor::new(&cursor.bytes()[0..operation_length as usize]);
if msg_type == MSG_TYPE_EVENT {
if let Some(event_data) = photon_protocol::deserialize_event_data(&mut payload) {
if event_data.code != 2 && event_data.parameters.get(&252u8).is_some() {
if let photon_protocol::Value::Short(code) = event_data.parameters.get(&252u8)? {
let packet = Packet{code: *code as usize, parameters: event_data.parameters};
debug!("EVENT: [{}] {:?}", packet.code, packet);
message = packet.decode();
}
}
}
} else if msg_type == MSG_TYPE_REQUEST {
if let Some(request) = photon_protocol::deserialize_operation_request(&mut payload) {
let code = request.code as usize + REQUEST_CONSTANT;
let packet = Packet{code, parameters: request.parameters};
debug!("REQUEST: [{}] {:?}", packet.code, packet);
message = packet.decode();
}
} else if msg_type == MSG_TYPE_RESPONSE {
if let Some(response) = photon_protocol::deserialize_operation_response(&mut payload) {
let code = response.code as usize + RESPONSE_CONSTANT;
let packet = Packet{code, parameters: response.parameters};
debug!("RESPONSE: [{}] {:?}", packet.code, packet);
message = packet.decode();
}
}
cursor.advance(operation_length as usize);
let last = cursor.bytes().len();
assert!(init - last == msg_len as usize - CMD_HEADER_LENGTH as usize);
message
}
-171
View File
@@ -1,171 +0,0 @@
#[macro_use]
extern crate cpython;
#[macro_use]
extern crate lazy_static;
mod game_protocol;
mod meter;
mod core;
use std::sync::{Mutex, Arc};
use cpython::PyList;
use cpython::PyObject;
use cpython::PyResult;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::FromPyObject;
use cpython::PyDict;
use crate::core::StatType;
struct PyMeter
{
value: Option<Arc<Mutex<meter::Meter>>>
}
impl PyMeter
{
fn new() -> Self {
Self{value: None}
}
fn initialize(&mut self, value: Arc<Mutex<meter::Meter>>) {
self.value = Some(value);
}
fn get(&mut self) -> Option<Arc<Mutex<meter::Meter>>> {
self.value.clone()
}
}
lazy_static! {
static ref METER: Mutex<PyMeter> = Mutex::new(PyMeter::new());
}
impl ToPyObject for core::PlayerStatistics {
type ObjectType = PyObject;
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))
.unwrap();
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))
.unwrap();
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()
}
}
impl ToPyObject for core::PlayerStatisticsVec {
type ObjectType = PyList;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.value().into_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
self.value().into_py_object(py)
}
}
impl <'source> FromPyObject<'source> for StatType {
fn extract(py: Python, obj: &'source PyObject) -> PyResult<Self> {
match obj.extract(py) {
Ok(n) => {
match n {
1 => Ok(StatType::LastFight),
2 => Ok(StatType::Zone),
3 => Ok(StatType::Overall),
_ => Ok(StatType::Unknown)
}
},
Err(e) => Err(e)
}
}
}
pub fn stats(py: Python, stat_type: StatType) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
if let Some(m) = meter.get() {
let meter = &mut *m.lock().unwrap();
return Ok(core::stats(&meter, stat_type).into_py_object(py))
}
Ok(PyList::new(py, Vec::<PyObject>::new().as_slice()))
}
pub fn reset(_py: Python, stat_type: StatType) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
if let Some(m) = meter.get() {
let meter = &mut *m.lock().unwrap();
core::reset(meter, stat_type);
}
Ok(0)
}
pub fn get_players_in_party(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
if let Some(m) = meter.get() {
let meter = &mut *m.lock().unwrap();
return Ok(core::get_players_in_party(&meter).into_py_object(py))
}
Ok(PyList::new(py, Vec::<PyObject>::new().as_slice()))
}
fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.initialize(core::initialize());
if let Some(m) = meter.get() {
let meter = &mut *m.lock().unwrap();
meter.configure(core::MeterConfig {
skip_non_party_members,
..Default::default()
})
}
Ok(0)
}
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(skip_non_party_members: bool)))?;
m.add(py, "stats", py_fn!(py, stats(stat_type: StatType)))?;
m.add(py, "reset", py_fn!(py, reset(stat_type: StatType)))?;
m.add(py, "get_players_in_party", py_fn!(py, get_players_in_party()))?;
Ok(())
});
-333
View File
@@ -1,333 +0,0 @@
extern crate chrono;
extern crate timer;
use std::collections::HashMap;
use log::*;
mod player;
mod traits;
mod types;
use player::Player;
pub use traits::*;
pub use types::*;
#[derive(Debug)]
pub struct Session {
players: HashMap<String, Player>,
}
impl Session {
fn new() -> Self {
Self {
players: HashMap::new(),
}
}
fn from(session: &Self) -> Self {
let mut players = HashMap::new();
for (player_name, player) in &session.players {
players.insert(player_name.clone(), Player::new(player.id));
}
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(),
})
.collect(),
)
}
pub fn cleanup_players(&mut self) {
let without_dmg = self
.players
.iter()
.filter(|(_, player)| player.damage() == 0.0)
.map(|(name, _)| name.clone())
.collect::<Vec<String>>();
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(player_name.to_owned(), Player::new(player_id));
}
}
#[derive(Default)]
pub struct MeterConfig {
pub skip_non_party_members: bool,
}
pub struct Meter {
zone_history: PlayerStatisticsVec,
zone_session: Option<Session>,
last_fight_session: Session,
main_player_id: Option<usize>,
party: Option<types::Party>,
config: MeterConfig,
}
impl Meter {
pub fn new() -> Self {
Self {
zone_history: PlayerStatisticsVec::new(),
zone_session: None,
last_fight_session: Session::new(),
main_player_id: None,
party: None,
config: Default::default(),
}
}
pub fn configure(&mut self, config: MeterConfig) {
self.config = config;
}
fn stats_filter(&self, player: &(&String, &Player)) -> bool {
if self.config.skip_non_party_members {
let is_main_player = if let Some(id) = &self.main_player_id { *id == player.1.id } else { false };
let is_in_party = if let Some(party) = &self.party { party.includes(&player.0) } else { false };
return is_main_player || is_in_party;
}
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) -> Option<()> {
let session = self.zone_session_mut()?;
session.add_player(name, id);
self.last_fight_session.add_player(name, id);
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();
}
#[allow(unused)]
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 PlayerEvents for Meter {
fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn DamageDealer>> {
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 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) {
info!("Main player {} registered with id {}", name, id);
self.main_player_id = Some(id);
if self.zone_session.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 {
info!("Main player ({}) left the zone, Creating new zone session.", id);
self.zone_session_mut()?.cleanup_players();
self.new_session();
}
Some(())
}
fn register_player(&mut self, name: &str, id: usize) {
if self.zone_session.is_none() {
info!("New player ({}) registered without session, creating new session", name);
self.new_session();
}
self.add_player(name, id);
}
fn register_combat_enter(&mut self, player_id: usize) -> Option<()> {
if self.combat_state() == CombatState::OutOfCombat {
self.last_fight_session = Session::from(&self.last_fight_session);
}
for player in self.get_damage_dealers_in_zone(player_id)? {
player.enter_combat();
}
Some(())
}
}
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);
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));
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();
self.zone_session = None;
self.last_fight_session = Session::new();
self.main_player_id = None;
Some(())
}
fn get_players_in_party(&self) -> Option<Vec<String>> {
if let Some(party) = &self.party {
let members = party.clone().members;
return Some(members.into_iter().collect())
}
None
}
}
impl traits::PartyEvents for Meter {
fn register_new_party(
&mut self,
player_names: &std::vec::Vec<std::string::String>,
id: usize,
) -> Option<()> {
self.party = Some(types::Party::new(id, player_names));
Some(())
}
fn register_new_member(&mut self, player_name: &str) -> Option<()> {
if let Some(party) = &mut self.party {
party.add_member(player_name);
}
Some(())
}
fn register_party_disbanded(&mut self) -> Option<()> {
self.party = None;
Some(())
}
}
#[test]
fn test_meter() {
let mut meter = Meter::new();
assert_eq!(meter.zone_stats(), None);
meter.register_main_player("name", 0);
assert!(meter.zone_stats().is_some());
}
-151
View File
@@ -1,151 +0,0 @@
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,
_timer: timer::Timer,
}
impl Time {
fn with(time_elapsed: Arc<Mutex<f32>>, combat_state: Arc<Mutex<CombatState>>) -> Time {
let _timer = timer::Timer::new();
let _guard = {
_timer.schedule_repeating(chrono::Duration::milliseconds(10), move || {
if *combat_state.lock().unwrap() == CombatState::InCombat {
*time_elapsed.lock().unwrap() += 10.0;
}
})
};
Self { _timer, _guard }
}
}
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<Mutex<f32>>,
combat_state: Arc<Mutex<CombatState>>,
_time: Option<Time>,
time_started: Instant,
fame: f32
}
impl Player {
pub fn new(id: usize) -> Self {
let time_elapsed = Arc::new(Mutex::new(0.0));
let combat_state = Arc::new(Mutex::new(CombatState::OutOfCombat));
Self {
id,
damage_dealt: 0.0,
time_elapsed,
combat_state,
_time: None,
time_started: Instant::now(),
fame: 0.0
}
}
}
impl DamageDealer for Player {
fn register_damage_dealt(&mut self, damage_dealt: f32) {
if self._time.is_none() {
let elapsed = self.time_elapsed.clone();
let state = self.combat_state.clone();
self._time = Some(Time::with(elapsed, state));
}
if *self.combat_state.lock().unwrap() == CombatState::OutOfCombat {
return
}
self.damage_dealt += damage_dealt
}
fn enter_combat(&mut self) {
*self.combat_state.lock().unwrap() = CombatState::InCombat;
}
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()
}
}
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);
}
}
-127
View File
@@ -1,127 +0,0 @@
#[cfg(test)]
use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use super::types::PlayerStatisticsVec;
#[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 PlayerEvents {
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);
fn register_leave(&mut self, id: usize) -> Option<()>;
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 {
player.register_damage_dealt(f32::abs(damage));
}
}
Some(())
}
fn register_combat_enter(&mut self, player_id: usize) -> Option<()> {
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<()> {
for player in self.get_damage_dealers_in_zone(player_id)? {
player.leave_combat();
}
Some(())
}
}
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 get_players_in_party(&self) -> Option<Vec<String>>;
fn reset_stats(&mut self) -> Option<()>;
}
pub trait PartyEvents {
fn register_new_party(&mut self, player_names: &std::vec::Vec<std::string::String>, id: usize) -> Option<()>;
fn register_new_member(&mut self, player_name: &str) -> Option<()>;
fn register_party_disbanded(&mut self) -> Option<()>;
}
-125
View File
@@ -1,125 +0,0 @@
use std::collections::HashSet;
use std::collections::HashMap;
use std::iter::FromIterator;
#[cfg(test)]
use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use super::traits::DamageStats;
use super::traits::FameStats;
#[derive(Debug, PartialEq, Clone)]
pub struct Party {
pub id: usize,
pub members: HashSet<String>
}
impl Party {
pub fn new(id: usize, members: &std::vec::Vec<std::string::String>) -> Self {
Self {
id,
members: HashSet::from_iter(members.iter().cloned()),
}
}
pub fn add_member(&mut self, member_name: &str) {
self.members.insert(member_name.to_string());
}
pub fn includes(&self, other: &str) -> bool {
return self.members.contains(other);
}
}
#[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
}
#[derive(Debug, PartialEq, Clone)]
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();
})
.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)
}
}