+ skip_non_party_members

This commit is contained in:
Wiktor Mazur
2019-09-27 22:35:14 +02:00
parent 6ec8b754ac
commit 9cd00e236f
8 changed files with 1026 additions and 716 deletions
+12 -7
View File
@@ -1,7 +1,8 @@
import os import os
import sys
import toml import toml
CFG_VERSION = '0.1' CFG_VERSION = '0.2'
default = """ default = """
[window] [window]
@@ -10,21 +11,25 @@ height = 200
font-size = '10px' font-size = '10px'
opacity = 0.5 opacity = 0.5
[app]
skip_non_party_players = true
[config] [config]
# do not change # do not change
version = '%s' version = '%s'
""" % (CFG_VERSION) """ % (CFG_VERSION)
_script_path = None
def set_script_path(path):
global _script_path
_script_path = path
_script_path = sys.argv[0] # pyinstaller creates tmpdir for python files, thus this is the way to get executable path
_config = None
def config(): def config():
global _script_path global _script_path
global _config
if _config:
return _config
conf_file = os.path.join(os.path.dirname( conf_file = os.path.join(os.path.dirname(
_script_path), 'albion-online-stats.cfg') _script_path), 'albion-online-stats.cfg')
+1 -4
View File
@@ -6,9 +6,6 @@ from PySide2.QtWidgets import QMessageBox
import libmeter import libmeter
from config import set_script_path
set_script_path(sys.argv[0]) # pyinstaller creates tmpdir for python files, thus this is the way to get executable path
from config import config from config import config
from main import MainWidget from main import MainWidget
from engine import initialize from engine import initialize
@@ -42,7 +39,7 @@ if __name__ == "__main__":
current_version, latest_version = (current_version(), latest_version()) current_version, latest_version = (current_version(), latest_version())
if current_version != latest_version: if latest_version and current_version != latest_version:
msg = QMessageBox() msg = QMessageBox()
msg.setIcon(QMessageBox.Warning) msg.setIcon(QMessageBox.Warning)
msg.setWindowTitle("Update available!") msg.setWindowTitle("Update available!")
+722
View File
@@ -0,0 +1,722 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::Mutex;
use std::thread;
use cpython::PyList;
use cpython::PyObject;
use cpython::PyResult;
use cpython::Python;
use cpython::ToPyObject;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use crate::game_protocol;
use crate::meter;
use meter::PartyEvents;
use meter::PlayerEvents;
use meter::ZoneStats;
lazy_static! {
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new());
}
pub fn get_zone_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_zone_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| Ok(v.into_py_object(py)),
)
}
pub fn get_overall_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_overall_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| Ok(v.into_py_object(py)),
)
}
pub fn get_last_fight_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_last_fight_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| Ok(v.into_py_object(py)),
)
}
pub fn new_zone_session(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.new_zone_session();
Ok(0)
}
pub fn reset_sessions(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.reset();
Ok(0)
}
pub fn new_last_fight_session(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.new_last_fight_session();
Ok(0)
}
pub fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult<u32> {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Trace,
Config::default(),
File::create("damage-meter.log").unwrap(),
)])
.unwrap();
configure(&mut METER.lock().unwrap(), meter::MeterConfig {
skip_non_party_members,
..Default::default()
});
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 METER.lock().unwrap();
if let Some(messages) = game_protocol::decode(&packet.payload) {
register_messages(meter, &messages);
}
}
}
});
Ok(0)
}
fn configure(meter: &mut meter::Meter, config: meter::MeterConfig) {
meter.configure(config);
}
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) {
debug!("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(())
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use cpython::{PyClone, PyDict, PyFloat, PyUnicode};
use game_protocol::message;
use game_protocol::Message;
mod helpers {
use super::*;
pub fn init() -> cpython::GILGuard {
let meter = &mut METER.lock().unwrap();
meter.reset();
super::configure(meter, Default::default());
Python::acquire_gil()
}
pub fn register(message: Message) {
let meter = &mut METER.lock().unwrap();
r(meter, &message);
}
fn r(meter: &mut meter::Meter, message: &game_protocol::Message) {
register_message(meter, &message);
}
pub fn configure(cfg: meter::MeterConfig) {
let meter = &mut METER.lock().unwrap();
super::configure(meter, cfg);
}
pub fn get_damage_dealer_in_zone_by_index(py: Python, index: usize) -> PyDict {
let zone_session = get_zone_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_damage_dealer_in_zone_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_zone_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_damage_dealer_in_zone_by_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_player_overall_index(py: Python, index: usize) -> PyDict {
let zone_session = get_overall_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_player_overall_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_overall_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_player_overall_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_player_last_fight_index(py: Python, index: usize) -> PyDict {
let zone_session = get_last_fight_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_player_last_fight_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_last_fight_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_player_last_fight_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_string(py: Python, stats: &PyDict, key: &str) -> String {
stats
.get_item(py, key)
.unwrap()
.cast_as::<PyUnicode>(py)
.unwrap()
.to_string_lossy(py)
.to_string()
}
pub fn get_float(py: Python, stats: &PyDict, key: &str) -> f64 {
stats
.get_item(py, key)
.unwrap()
.cast_as::<PyFloat>(py)
.unwrap()
.value(py)
}
}
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 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 guard = helpers::init();
let py = guard.python();
assert_eq!(get_zone_session(py).unwrap().len(py), 0);
}
#[test]
fn test_new_player_appears() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let zone_session = get_zone_session(py).unwrap();
assert_eq!(zone_session.len(py), 1);
}
#[test]
fn test_new_player_stats() {
let guard = helpers::init();
let py = guard.python();
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!(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);
}
#[test]
fn test_damage_aggregation() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0);
}
#[test]
fn test_new_player_damage() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
}
#[test]
fn test_new_player_damage_reset() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
new_zone_session(py).unwrap();
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
}
#[test]
fn test_zone_detection() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::Leave(message::Leave::new(1)));
helpers::register(Message::CharacterStats(message::CharacterStats::new(2)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
}
#[test]
fn test_two_players_in_the_zone() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"MAIN_CH1", 1,
)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"CH1", 2,
)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::Leave(message::Leave::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1");
assert!(stats.is_none());
}
#[test]
fn test_overall_damage() {
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_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::Leave(message::Leave::new(1)));
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_float(py, &stats, "damage"), 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0);
}
#[test]
fn test_last_fight_damage() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"MAIN_CH1", 1,
)));
let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(1),
));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
}
#[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 guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"1", 1,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
assert!(helpers::get_player_last_fight_by_name(py, "1").is_some());
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"2", 2,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"3", 3,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(3),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(3)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(3),
));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(1),
));
macro_rules! assert_named_player_dmg {
($id:expr, $dmg:expr) => {
assert_eq!(
helpers::get_float(
py,
&helpers::get_player_last_fight_by_name(py, $id).unwrap(),
"damage"
),
$dmg
);
};
}
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(2),
));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(3),
));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 0.0);
assert_named_player_dmg!("3", 0.0);
}
#[test]
fn test_party_member_filter() {
let guard = helpers::init();
let py = guard.python();
helpers::configure(meter::MeterConfig {
skip_non_party_members: true,
..Default::default()
});
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"main_player", 1,
)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some());
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"other_player", 2,
)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some());
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_none());
helpers::register(Message::PartyNew(message::PartyNew::new_list_of_named(
&["main_player", "other_player"],
1,
)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some());
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "other_player").is_some());
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"yet_another_other_player", 2,
)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_none());
helpers::register(Message::PartyJoin(message::PartyJoin::new_named(&"yet_another_other_player", 1)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "yet_another_other_player").is_some());
helpers::register(Message::PartyDisbanded(message::PartyDisbanded::new(1)));
assert!(helpers::get_damage_dealer_in_zone_by_name(py, "main_player").is_some());
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());
}
}
+77 -1
View File
@@ -39,6 +39,32 @@ macro_rules! deserialize_string {
}; };
} }
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 { macro_rules! deserialize_float {
($val:expr, $index:expr, $name:expr) => { ($val:expr, $index:expr, $name:expr) => {
if let Some(p) = $val.get(&$index) { if let Some(p) = $val.get(&$index) {
@@ -222,6 +248,50 @@ impl Died {
} }
} }
#[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)] #[derive(Debug)]
pub enum Message { pub enum Message {
Leave(Leave), Leave(Leave),
@@ -230,7 +300,10 @@ pub enum Message {
HealthUpdate(HealthUpdate), HealthUpdate(HealthUpdate),
RegenerationHealthChanged(RegenerationHealthChanged), RegenerationHealthChanged(RegenerationHealthChanged),
CharacterStats(CharacterStats), CharacterStats(CharacterStats),
Died(Died) Died(Died),
PartyNew(PartyNew),
PartyJoin(PartyJoin),
PartyDisbanded(PartyDisbanded)
} }
impl Packet { impl Packet {
@@ -242,6 +315,9 @@ impl Packet {
63 => ChatSay::encode(self.parameters), 63 => ChatSay::encode(self.parameters),
79 => RegenerationHealthChanged::encode(self.parameters), 79 => RegenerationHealthChanged::encode(self.parameters),
149 => Died::encode(self.parameters), 149 => Died::encode(self.parameters),
210 => PartyNew::encode(self.parameters),
112 => PartyJoin::encode(self.parameters),
211 => PartyDisbanded::encode(self.parameters),
1001 => CharacterStats::encode(self.parameters), 1001 => CharacterStats::encode(self.parameters),
_ => None, _ => None,
} }
+10 -641
View File
@@ -1,162 +1,26 @@
#[macro_use] #[macro_use]
extern crate cpython; extern crate cpython;
#[macro_use] #[macro_use]
extern crate lazy_static; extern crate lazy_static;
extern crate bytes;
extern crate packet_sniffer;
extern crate photon_protocol;
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::Mutex;
use std::thread;
use cpython::{PyDict, PyList, PyObject, PyResult, Python, PythonObject, ToPyObject};
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
mod game_protocol; mod game_protocol;
mod meter; mod meter;
use meter::PlayerEvents; mod core;
use meter::ZoneStats;
lazy_static! { use crate::core::get_last_fight_session;
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new()); use crate::core::get_overall_session;
} use crate::core::get_zone_session;
use crate::core::initialize;
use crate::core::new_last_fight_session;
use crate::core::new_zone_session;
use crate::core::reset_sessions;
impl ToPyObject for meter::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.into_object()
}
}
fn get_zone_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_zone_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| { Ok(v.into_py_object(py)) }
)
}
fn get_overall_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_overall_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| { Ok(v.into_py_object(py)) }
)
}
fn get_last_fight_session(py: Python) -> PyResult<PyList> {
let meter = &mut METER.lock().unwrap();
meter.get_last_fight_session().map_or_else(
|| Ok(PyList::new(py, Vec::<PyObject>::new().as_slice())),
|v| { Ok(v.into_py_object(py)) }
)
}
fn new_zone_session(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.new_zone_session();
Ok(0)
}
fn reset_sessions(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.reset();
Ok(0)
}
fn new_last_fight_session(_py: Python) -> PyResult<u32> {
let meter = &mut METER.lock().unwrap();
meter.new_last_fight_session();
Ok(0)
}
fn initialize(_py: Python) -> PyResult<u32> {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Trace,
Config::default(),
File::create("damage-meter.log").unwrap(),
)])
.unwrap();
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 METER.lock().unwrap();
if let Some(messages) = game_protocol::decode(&packet.payload) {
register_messages(meter, &messages);
}
}
}
});
Ok(0)
}
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 PlayerEvents, message: &game_protocol::Message) {
debug!("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(()),
_ => {}
}
}
py_module_initializer!(libmeter, initliblibmeter, PyInit_libmeter, |py, m| { py_module_initializer!(libmeter, initliblibmeter, PyInit_libmeter, |py, m| {
m.add(py, "__doc__", "This module is implemented in Rust")?; m.add(py, "__doc__", "This module is implemented in Rust")?;
m.add(py, "initialize", py_fn!(py, initialize()))?; m.add(py, "initialize", py_fn!(py, initialize(skip_non_party_members: bool)))?;
m.add(py, "new_zone_session", py_fn!(py, new_zone_session()))?; m.add(py, "new_zone_session", py_fn!(py, new_zone_session()))?;
m.add(py, "get_overall_session", py_fn!(py, get_overall_session()))?; m.add(py, "get_overall_session", py_fn!(py, get_overall_session()))?;
m.add( m.add(
@@ -173,498 +37,3 @@ py_module_initializer!(libmeter, initliblibmeter, PyInit_libmeter, |py, m| {
m.add(py, "get_zone_session", py_fn!(py, get_zone_session()))?; m.add(py, "get_zone_session", py_fn!(py, get_zone_session()))?;
Ok(()) Ok(())
}); });
#[cfg(test)]
mod tests {
use super::*;
use cpython::{PyFloat, PyUnicode, PyClone};
use game_protocol::message;
use game_protocol::Message;
mod helpers {
use super::*;
pub fn init() -> cpython::GILGuard {
let meter = &mut METER.lock().unwrap();
meter.reset();
Python::acquire_gil()
}
pub fn register(message: Message) {
let meter = &mut METER.lock().unwrap();
r(meter, &message);
}
fn r(meter: &mut meter::Meter, message: &game_protocol::Message) {
register_message(meter, &message);
}
pub fn get_damage_dealer_in_zone_by_index(py: Python, index: usize) -> PyDict {
let zone_session = get_zone_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_damage_dealer_in_zone_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_zone_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_damage_dealer_in_zone_by_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_player_overall_index(py: Python, index: usize) -> PyDict {
let zone_session = get_overall_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_player_overall_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_overall_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_player_overall_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_player_last_fight_index(py: Python, index: usize) -> PyDict {
let zone_session = get_last_fight_session(py).unwrap();
let stat = zone_session.get_item(py, index);
let player = stat.cast_as::<PyDict>(py).unwrap().clone_ref(py);
player
}
pub fn get_player_last_fight_by_name(py: Python, name: &str) -> Option<PyDict> {
let zone_session_len = get_last_fight_session(py).unwrap().len(py);
for idx in 0..zone_session_len {
let player = get_player_last_fight_index(py, idx);
if get_string(py, &player, "player") == name {
return Some(player);
}
}
None
}
pub fn get_string(py: Python, stats: &PyDict, key: &str) -> String {
stats
.get_item(py, key)
.unwrap()
.cast_as::<PyUnicode>(py)
.unwrap()
.to_string_lossy(py)
.to_string()
}
pub fn get_float(py: Python, stats: &PyDict, key: &str) -> f64 {
stats
.get_item(py, key)
.unwrap()
.cast_as::<PyFloat>(py)
.unwrap()
.value(py)
}
}
trait Testing {
fn new(source: usize) -> Self;
}
trait NamedTesting {
fn new_named(name: &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 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,
}
}
}
#[test]
fn test_empty_session() {
let guard = helpers::init();
let py = guard.python();
assert_eq!(get_zone_session(py).unwrap().len(py), 0);
}
#[test]
fn test_new_player_appears() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let zone_session = get_zone_session(py).unwrap();
assert_eq!(zone_session.len(py), 1);
}
#[test]
fn test_new_player_stats() {
let guard = helpers::init();
let py = guard.python();
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!(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);
}
#[test]
fn test_damage_aggregation() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0);
}
#[test]
fn test_new_player_damage() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
}
#[test]
fn test_new_player_damage_reset() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::NewCharacter(message::NewCharacter::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
new_zone_session(py).unwrap();
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
}
#[test]
fn test_zone_detection() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::Leave(message::Leave::new(1)));
helpers::register(Message::CharacterStats(message::CharacterStats::new(2)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2)));
let stats = helpers::get_damage_dealer_in_zone_by_index(py, 0);
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
}
#[test]
fn test_two_players_in_the_zone() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"MAIN_CH1", 1,
)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"CH1", 2,
)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::Leave(message::Leave::new(1)));
let stats = helpers::get_damage_dealer_in_zone_by_name(py, "CH1");
assert!(stats.is_none());
}
#[test]
fn test_overall_damage() {
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_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::Leave(message::Leave::new(1)));
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_float(py, &stats, "damage"), 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_overall_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 20.0);
}
#[test]
fn test_last_fight_damage() {
let guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"MAIN_CH1", 1,
)));
let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_string(py, &stats, "player"), "MAIN_CH1");
assert_eq!(helpers::get_float(py, &stats, "damage"), 0.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
let stats = helpers::get_player_last_fight_by_name(py, "MAIN_CH1").unwrap();
assert_eq!(helpers::get_float(py, &stats, "damage"), 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(1),
));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
}
#[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 guard = helpers::init();
let py = guard.python();
helpers::register(Message::CharacterStats(message::CharacterStats::new_named(
"1", 1,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
assert!(helpers::get_player_last_fight_by_name(py, "1").is_some());
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"2", 2,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(2)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(2),
));
helpers::register(Message::NewCharacter(message::NewCharacter::new_named(
"3", 3,
)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(3),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(3)));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(3),
));
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(1),
));
macro_rules! assert_named_player_dmg {
($id:expr, $dmg:expr) => {
assert_eq!(
helpers::get_float(
py,
&helpers::get_player_last_fight_by_name(py, $id).unwrap(),
"damage"
),
$dmg
);
}
}
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(2),
));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::enabled(3),
));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 10.0);
assert_named_player_dmg!("3", 10.0);
helpers::register(Message::RegenerationHealthChanged(
message::RegenerationHealthChanged::disabled(1),
));
helpers::register(Message::HealthUpdate(message::HealthUpdate::new(1)));
assert_named_player_dmg!("1", 10.0);
assert_named_player_dmg!("2", 0.0);
assert_named_player_dmg!("3", 0.0);
}
}
+79 -48
View File
@@ -14,12 +14,9 @@ use player::Player;
pub use traits::*; pub use traits::*;
pub use types::*; pub use types::*;
#[derive(Hash, Eq, PartialEq, Clone, Debug)]
pub struct PlayerName(String);
#[derive(Debug)] #[derive(Debug)]
pub struct Session { pub struct Session {
players: HashMap<PlayerName, Player>, players: HashMap<String, Player>,
} }
impl Session { impl Session {
@@ -38,16 +35,22 @@ impl Session {
Self { players } Self { players }
} }
pub fn stats(&self) -> PlayerStatisticsVec { pub fn stats<F>(&self, filter: F) -> PlayerStatisticsVec
where
F: Fn(&(&String, &Player)) -> bool,
{
PlayerStatisticsVec::from(
self.players self.players
.iter() .iter()
.filter(filter)
.map(|(name, player)| PlayerStatistics { .map(|(name, player)| PlayerStatistics {
player: name.0.to_owned(), player: name.to_owned(),
damage: player.damage(), damage: player.damage(),
time_in_combat: player.time_in_combat(), time_in_combat: player.time_in_combat(),
dps: player.dps(), dps: player.dps(),
}) })
.collect() .collect(),
)
} }
pub fn cleanup_players(&mut self) { pub fn cleanup_players(&mut self) {
@@ -56,7 +59,7 @@ impl Session {
.iter() .iter()
.filter(|(_, player)| player.damage() == 0.0) .filter(|(_, player)| player.damage() == 0.0)
.map(|(name, _)| name.clone()) .map(|(name, _)| name.clone())
.collect::<Vec<PlayerName>>(); .collect::<Vec<String>>();
for w in without_dmg { for w in without_dmg {
self.players.remove_entry(&w); self.players.remove_entry(&w);
} }
@@ -72,27 +75,13 @@ impl Session {
fn add_player(&mut self, player_name: &str, player_id: usize) { fn add_player(&mut self, player_name: &str, player_id: usize) {
self.players self.players
.insert(PlayerName(player_name.to_owned()), Player::new(player_id)); .insert(player_name.to_owned(), Player::new(player_id));
} }
} }
fn merge_stats(a : &PlayerStatisticsVec, b : &PlayerStatisticsVec) -> PlayerStatisticsVec { #[derive(Default)]
let merged = [&a[..], &b[..]].concat().iter().fold( pub struct MeterConfig {
HashMap::<String, PlayerStatistics>::new(), pub skip_non_party_members: bool,
|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();
})
.or_insert(stat.clone());
acc
},
);
return merged.iter().map(|(_, v)| v.clone()).collect()
} }
pub struct Meter { pub struct Meter {
@@ -100,36 +89,55 @@ pub struct Meter {
zone_session: Option<Session>, zone_session: Option<Session>,
last_fight_session: Session, last_fight_session: Session,
main_player_id: Option<usize>, main_player_id: Option<usize>,
party: Option<types::Party>,
config: MeterConfig,
} }
impl Meter { impl Meter {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
zone_history: Vec::new(), zone_history: PlayerStatisticsVec::new(),
zone_session: None, zone_session: None,
last_fight_session: Session::new(), last_fight_session: Session::new(),
main_player_id: None, 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> { fn zone_session_mut(&mut self) -> Option<&mut Session> {
match &mut self.zone_session { match &mut self.zone_session {
Some(s) => Some(s), Some(s) => Some(s),
None => None None => None,
} }
} }
fn zone_session(&self) -> Option<&Session> { fn zone_session(&self) -> Option<&Session> {
match &self.zone_session { match &self.zone_session {
Some(s) => Some(s), Some(s) => Some(s),
None => None None => None,
} }
} }
fn sessions_mut(&mut self) -> Option<(&mut Session, &mut Session)> { fn sessions_mut(&mut self) -> Option<(&mut Session, &mut Session)> {
match &mut self.zone_session { match &mut self.zone_session {
Some(s) => Some((s, &mut self.last_fight_session)), Some(s) => Some((s, &mut self.last_fight_session)),
None => None None => None,
} }
} }
@@ -142,19 +150,23 @@ impl Meter {
fn new_session(&mut self) { fn new_session(&mut self) {
if let Some(zone) = self.zone_session() { if let Some(zone) = self.zone_session() {
self.zone_history = merge_stats(&self.zone_history, &zone.stats()); self.zone_history = PlayerStatisticsVec::merged(
&self.zone_history,
&zone.stats(|p| self.stats_filter(p)),
);
} }
self.zone_session = Some(Session::new()); self.zone_session = Some(Session::new());
self.last_fight_session = Session::new(); self.last_fight_session = Session::new();
} }
#[allow(unused)] #[allow(unused)]
fn combat_state(&self) -> CombatState { fn combat_state(&self) -> CombatState {
if self.last_fight_session if self
.last_fight_session
.players() .players()
.iter() .iter()
.any(|p| p.combat_state() == CombatState::InCombat) { .any(|p| p.combat_state() == CombatState::InCombat)
{
return CombatState::InCombat; return CombatState::InCombat;
} }
@@ -167,10 +179,7 @@ impl PlayerEvents for Meter {
let (zone, last_fight) = self.sessions_mut()?; let (zone, last_fight) = self.sessions_mut()?;
let las_fight_session_player = last_fight.get_player_by_id(player_id)?; let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
let zone_player = zone.get_player_by_id(player_id)?; let zone_player = zone.get_player_by_id(player_id)?;
Some(vec![ Some(vec![zone_player, las_fight_session_player])
zone_player,
las_fight_session_player,
])
} }
fn register_main_player(&mut self, name: &str, id: usize) { fn register_main_player(&mut self, name: &str, id: usize) {
@@ -213,13 +222,12 @@ impl PlayerEvents for Meter {
Some(()) Some(())
} }
} }
impl ZoneStats for Meter { impl ZoneStats for Meter {
fn get_zone_session(&self) -> Option<Vec<PlayerStatistics>> { fn get_zone_session(&self) -> Option<PlayerStatisticsVec> {
let last_session = self.zone_session()?; let last_session = self.zone_session()?;
Some(last_session.stats()) Some(last_session.stats(|p| self.stats_filter(p)))
} }
fn new_zone_session(&mut self) -> Option<()> { fn new_zone_session(&mut self) -> Option<()> {
@@ -231,14 +239,17 @@ impl ZoneStats for Meter {
fn get_overall_session(&self) -> Option<PlayerStatisticsVec> { fn get_overall_session(&self) -> Option<PlayerStatisticsVec> {
if let Some(zone) = self.zone_session() { if let Some(zone) = self.zone_session() {
return Some(merge_stats(&self.zone_history, &zone.stats())); return Some(PlayerStatisticsVec::merged(
&self.zone_history,
&zone.stats(|p| self.stats_filter(p)),
));
} }
None None
} }
fn reset(&mut self) { fn reset(&mut self) {
self.zone_history = vec![]; self.zone_history = PlayerStatisticsVec::new();
self.zone_session = None; self.zone_session = None;
self.last_fight_session = Session::new(); self.last_fight_session = Session::new();
self.main_player_id = None; self.main_player_id = None;
@@ -246,7 +257,7 @@ impl ZoneStats for Meter {
fn get_last_fight_session(&self) -> Option<PlayerStatisticsVec> { fn get_last_fight_session(&self) -> Option<PlayerStatisticsVec> {
let last_session = &self.last_fight_session; let last_session = &self.last_fight_session;
Some(last_session.stats()) Some(last_session.stats(|p| self.stats_filter(p)))
} }
fn new_last_fight_session(&mut self) -> Option<()> { fn new_last_fight_session(&mut self) -> Option<()> {
@@ -255,6 +266,30 @@ impl ZoneStats for Meter {
} }
} }
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] #[test]
fn test_meter() { fn test_meter() {
let mut meter = Meter::new(); let mut meter = Meter::new();
@@ -263,8 +298,4 @@ fn test_meter() {
meter.register_main_player("name", 0); meter.register_main_player("name", 0);
assert!(meter.get_zone_session().is_some()); assert!(meter.get_zone_session().is_some());
assert_eq!(
meter.get_zone_session().unwrap()[0].player,
"name".to_owned()
);
} }
+10 -4
View File
@@ -1,4 +1,4 @@
use super::types::PlayerStatistics; use super::types::PlayerStatisticsVec;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum CombatState { pub enum CombatState {
@@ -69,11 +69,17 @@ pub trait PlayerEvents {
pub trait ZoneStats { pub trait ZoneStats {
fn reset(&mut self); fn reset(&mut self);
fn get_zone_session(&self) -> Option<Vec<PlayerStatistics>>; fn get_zone_session(&self) -> Option<PlayerStatisticsVec>;
fn new_zone_session(&mut self) -> Option<()>; fn new_zone_session(&mut self) -> Option<()>;
fn get_overall_session(&self) -> Option<Vec<PlayerStatistics>>; fn get_overall_session(&self) -> Option<PlayerStatisticsVec>;
fn get_last_fight_session(&self) -> Option<Vec<PlayerStatistics>>; fn get_last_fight_session(&self) -> Option<PlayerStatisticsVec>;
fn new_last_fight_session(&mut self) -> Option<()>; fn new_last_fight_session(&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<()>;
}
+105 -1
View File
@@ -1,5 +1,37 @@
use std::collections::HashMap;
use cpython::PythonObject;
use cpython::ToPyObject;
use cpython::Python;
use cpython::PyObject;
use cpython::PyDict;
use cpython::PyList;
use super::traits::DamageStats; use super::traits::DamageStats;
#[derive(Debug, PartialEq, Clone)]
pub struct Party {
pub id: usize,
pub members: Vec<String>
}
impl Party {
pub fn new(id: usize, members: &std::vec::Vec<std::string::String>) -> Self {
Self {
id,
members: members.clone(),
}
}
pub fn add_member(&mut self, member_name: &str) {
self.members.push(member_name.to_string());
}
pub fn includes(&self, other: &str) -> bool {
return self.members.iter().find(|m| **m == other).is_some();
}
}
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
pub struct PlayerStatistics { pub struct PlayerStatistics {
pub player: String, pub player: String,
@@ -8,7 +40,44 @@ pub struct PlayerStatistics {
pub dps: f32, pub dps: f32,
} }
pub type PlayerStatisticsVec = Vec<PlayerStatistics>; #[derive(Debug, PartialEq, Clone)]
pub struct PlayerStatisticsVec {
_vec: Vec<PlayerStatistics>
}
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 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();
})
.or_insert(stat.clone());
acc
},
);
Self {
_vec: merged.iter().map(|(_, v)| v.clone()).collect()
}
}
}
impl DamageStats for PlayerStatistics { impl DamageStats for PlayerStatistics {
fn damage(&self) -> f32 { fn damage(&self) -> f32 {
@@ -18,3 +87,38 @@ impl DamageStats for PlayerStatistics {
self.time_in_combat self.time_in_combat
} }
} }
impl ToPyObject for 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.into_object()
}
}
impl ToPyObject for PlayerStatisticsVec {
type ObjectType = PyList;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self._vec.into_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
self._vec.clone().into_py_object(py)
}
}