Repository cleanup
This commit is contained in:
Generated
+1009
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,27 @@
|
||||
[package]
|
||||
name = "libaostats"
|
||||
version = "0.1.0"
|
||||
authors = ["Wiktor Mazur <wiktormazur1@gmail.com>"]
|
||||
edition = "2018"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[lib]
|
||||
name = "libaostats"
|
||||
crate-type = ["dylib"]
|
||||
|
||||
[dependencies.cpython]
|
||||
version = "0.3"
|
||||
|
||||
[dependencies]
|
||||
packet_sniffer = { path = "./lib/packet-sniffer" }
|
||||
photon_protocol = { path = "./lib/photon-protocol" }
|
||||
bytes = "0.4"
|
||||
simplelog = "0.6"
|
||||
timer = "0.1"
|
||||
chrono = "0.4"
|
||||
log = { version = "0.4", features = ["std"] }
|
||||
lazy_static = "1.2"
|
||||
|
||||
[dev-dependencies]
|
||||
fake_clock = "0.3.0"
|
||||
@@ -0,0 +1 @@
|
||||
from libaostats import *
|
||||
@@ -0,0 +1,11 @@
|
||||
[package]
|
||||
name = "packet_sniffer"
|
||||
version = "0.1.0"
|
||||
authors = ["Wiktor Mazur <wiktormazur1@gmail.com>"]
|
||||
edition = "2018"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
pnet = "0.22.0"
|
||||
log = { version = "0.4", features = ["std"] }
|
||||
@@ -0,0 +1,169 @@
|
||||
extern crate pnet;
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use std::net::IpAddr;
|
||||
use std::sync::mpsc::Sender;
|
||||
use std::thread;
|
||||
|
||||
use pnet::datalink::{self, NetworkInterface};
|
||||
use pnet::packet::ethernet::{EtherTypes, EthernetPacket, MutableEthernetPacket};
|
||||
use pnet::packet::ip::{IpNextHeaderProtocol, IpNextHeaderProtocols};
|
||||
use pnet::packet::ipv4::Ipv4Packet;
|
||||
use pnet::packet::ipv6::Ipv6Packet;
|
||||
use pnet::packet::udp;
|
||||
use pnet::packet::Packet;
|
||||
use pnet::util::MacAddr;
|
||||
|
||||
use log::*;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct UdpPacket {
|
||||
pub interface_name: String,
|
||||
pub source_address: IpAddr,
|
||||
pub source_port: u16,
|
||||
pub destination_address: IpAddr,
|
||||
pub destination_port: u16,
|
||||
pub length: u16,
|
||||
pub payload: Vec<u8>
|
||||
}
|
||||
|
||||
pub fn receive(tx: Sender<UdpPacket>) {
|
||||
let shared_tx = Arc::new(Mutex::new(tx));
|
||||
|
||||
use pnet::datalink::Channel::Ethernet;
|
||||
|
||||
let interfaces = datalink::interfaces()
|
||||
.into_iter()
|
||||
.filter(|i| !i.is_loopback());
|
||||
|
||||
info!("Found interfaces: {:?}", interfaces);
|
||||
|
||||
for interface in interfaces {
|
||||
let tx = shared_tx.clone();
|
||||
let config = pnet::datalink::Config{
|
||||
write_buffer_size: 65536,
|
||||
read_buffer_size: 65536,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
// Create a channel to receive on
|
||||
let (_, mut rx) = match datalink::channel(&interface, config) {
|
||||
Ok(Ethernet(tx, rx)) => (tx, rx),
|
||||
Ok(_) => {
|
||||
warn!("packetdump: unhandled channel type");
|
||||
continue;
|
||||
},
|
||||
Err(e) => {
|
||||
warn!("packetdump: unable to create channel: {}", e);
|
||||
continue;
|
||||
},
|
||||
};
|
||||
|
||||
thread::spawn(move || {
|
||||
loop {
|
||||
let mut buf: [u8; 1600] = [0u8; 1600];
|
||||
let mut fake_ethernet_frame = MutableEthernetPacket::new(&mut buf[..]).unwrap();
|
||||
match rx.next() {
|
||||
Ok(packet) => {
|
||||
if cfg!(target_os = "macos")
|
||||
&& interface.is_up()
|
||||
&& !interface.is_broadcast()
|
||||
&& !interface.is_loopback()
|
||||
&& interface.is_point_to_point()
|
||||
{
|
||||
// Maybe is TUN interface
|
||||
let version = Ipv4Packet::new(&packet).unwrap().get_version();
|
||||
if version == 4 {
|
||||
fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0));
|
||||
fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
|
||||
fake_ethernet_frame.set_ethertype(EtherTypes::Ipv4);
|
||||
fake_ethernet_frame.set_payload(&packet);
|
||||
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
|
||||
continue;
|
||||
} else if version == 6 {
|
||||
fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0));
|
||||
fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
|
||||
fake_ethernet_frame.set_ethertype(EtherTypes::Ipv6);
|
||||
fake_ethernet_frame.set_payload(&packet);
|
||||
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
handle_ethernet_frame(&interface, &EthernetPacket::new(packet).unwrap(), &tx);
|
||||
}
|
||||
Err(e) => panic!("packetdump: unable to receive packet: {}", e),
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
|
||||
let interface_name = &interface.name[..];
|
||||
match ethernet.get_ethertype() {
|
||||
EtherTypes::Ipv4 => handle_ipv4_packet(interface_name, ethernet, &tx),
|
||||
EtherTypes::Ipv6 => handle_ipv6_packet(interface_name, ethernet, &tx),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
|
||||
let header = Ipv4Packet::new(ethernet.payload());
|
||||
if let Some(header) = header {
|
||||
handle_transport_protocol(
|
||||
interface_name,
|
||||
IpAddr::V4(header.get_source()),
|
||||
IpAddr::V4(header.get_destination()),
|
||||
header.get_next_level_protocol(),
|
||||
header.payload(),
|
||||
&tx
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
|
||||
let header = Ipv6Packet::new(ethernet.payload());
|
||||
if let Some(header) = header {
|
||||
handle_transport_protocol(
|
||||
interface_name,
|
||||
IpAddr::V6(header.get_source()),
|
||||
IpAddr::V6(header.get_destination()),
|
||||
header.get_next_header(),
|
||||
header.payload(),
|
||||
&tx
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_transport_protocol(
|
||||
interface_name: &str,
|
||||
source: IpAddr,
|
||||
destination: IpAddr,
|
||||
protocol: IpNextHeaderProtocol,
|
||||
packet: &[u8],
|
||||
tx: &Arc<Mutex<Sender<UdpPacket>>>
|
||||
) {
|
||||
match protocol {
|
||||
IpNextHeaderProtocols::Udp => {
|
||||
handle_udp_packet(interface_name, source, destination, packet, &tx)
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_udp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, packet: &[u8], tx: &Arc<Mutex<Sender<UdpPacket>>>) {
|
||||
let udp = udp::UdpPacket::new(packet);
|
||||
let tx = tx.lock().unwrap();
|
||||
if let Some(udp) = udp {
|
||||
tx.send(UdpPacket{
|
||||
interface_name: String::from(interface_name),
|
||||
source_address: source,
|
||||
source_port: udp.get_source(),
|
||||
destination_address: destination,
|
||||
destination_port: udp.get_destination(),
|
||||
length: udp.get_length(),
|
||||
payload: Vec::from(udp.payload())
|
||||
}).unwrap();
|
||||
}
|
||||
}
|
||||
Generated
+48
@@ -0,0 +1,48 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
[[package]]
|
||||
name = "byteorder"
|
||||
version = "1.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "bytes"
|
||||
version = "0.4.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "iovec"
|
||||
version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "protocol16"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.2.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[metadata]
|
||||
"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
|
||||
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
|
||||
"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
|
||||
"checksum libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)" = "d44e80633f007889c7eff624b709ab43c92d708caad982295768a7b13ca3b5eb"
|
||||
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
|
||||
@@ -0,0 +1,10 @@
|
||||
[package]
|
||||
name = "photon_protocol"
|
||||
version = "0.1.0"
|
||||
authors = ["Wiktor Mazur <wiktormazur1@gmail.com>"]
|
||||
edition = "2018"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
bytes = "0.4"
|
||||
@@ -0,0 +1,747 @@
|
||||
extern crate bytes;
|
||||
mod types;
|
||||
|
||||
use std::{error, fmt};
|
||||
use std::io::{Read, Cursor};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use bytes::Buf;
|
||||
|
||||
|
||||
use types::TypeCode;
|
||||
|
||||
pub use types::Parameters;
|
||||
pub use types::Value;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DeserializationError {
|
||||
type_code: u8,
|
||||
}
|
||||
|
||||
impl fmt::Display for DeserializationError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "Failed to deserialize type_code {}", self.type_code)
|
||||
}
|
||||
}
|
||||
|
||||
impl error::Error for DeserializationError {
|
||||
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn deserialize_boolean(buf: &mut Cursor<&[u8]>) -> Option<bool> {
|
||||
let v = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v != 0)
|
||||
}
|
||||
|
||||
pub fn deserialize_byte(buf: &mut Cursor<&[u8]>) -> Option<u8> {
|
||||
let v = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_float(buf: &mut Cursor<&[u8]>) -> Option<f32> {
|
||||
let v = if buf.remaining() >= 4 {
|
||||
buf.get_f32_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_integer(buf: &mut Cursor<&[u8]>) -> Option<u32> {
|
||||
let v = if buf.remaining() >= 4 {
|
||||
buf.get_u32_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_long(buf: &mut Cursor<&[u8]>) -> Option<i64> {
|
||||
let v = if buf.remaining() >= 8 {
|
||||
buf.get_i64_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_short(buf: &mut Cursor<&[u8]>) -> Option<i16> {
|
||||
let v = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_double(buf: &mut Cursor<&[u8]>) -> Option<f64> {
|
||||
let v = if buf.remaining() >= 8 {
|
||||
buf.get_f64_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_string(buf: &mut Cursor<&[u8]>) -> Option<String> {
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut local_buffer = vec![0; size as usize];
|
||||
|
||||
if let Ok(_) = buf.read_exact(&mut local_buffer[..]) {
|
||||
if let Ok(s) = String::from_utf8(local_buffer) {
|
||||
return Some(s);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn deserialize_string_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<String>> {
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be() as usize
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
for _ in 0..size {
|
||||
if let Some(v) = deserialize_string(buf) {
|
||||
value.push(v);
|
||||
}
|
||||
}
|
||||
|
||||
Some(value)
|
||||
}
|
||||
|
||||
pub fn deserialize_byte_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<u8>> {
|
||||
let size = buf.get_u32_be() as usize;
|
||||
let mut value = vec![];
|
||||
|
||||
for _ in 0..size {
|
||||
if buf.remaining() > 0 {
|
||||
value.push(buf.get_u8());
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
|
||||
Some(value)
|
||||
}
|
||||
|
||||
pub fn deserialize_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
if size == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
for _ in 0..size {
|
||||
if let Ok(v) = deserialize(type_code, buf) {
|
||||
value.push(v);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Some(value)
|
||||
}
|
||||
|
||||
pub fn deserialize_dictionary(buf: &mut Cursor<&[u8]>) -> Option<HashMap<String, Value>> {
|
||||
let key_type_code = buf.get_u8();
|
||||
let value_type_code = buf.get_u8();
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
|
||||
if size == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut value: HashMap<String, Value> = HashMap::new();
|
||||
|
||||
for _ in 0..size {
|
||||
let key_code = if key_type_code == 0 || key_type_code == 42 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
key_type_code
|
||||
};
|
||||
|
||||
let key = deserialize(key_code, buf);
|
||||
|
||||
let value_code = if value_type_code == 0 || value_type_code == 42 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
value_type_code
|
||||
};
|
||||
let val = deserialize(value_code, buf);
|
||||
value.insert(format!("{}", key.unwrap()), val.unwrap());
|
||||
}
|
||||
|
||||
Some(value)
|
||||
}
|
||||
|
||||
fn deserialize_parameter_table(buf: &mut Cursor<&[u8]>) -> HashMap<u8, Value> {
|
||||
let mut value: HashMap<u8, Value> = HashMap::new();
|
||||
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return value;
|
||||
};
|
||||
|
||||
for _ in 0..size {
|
||||
let key_type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
let value_type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
let val = deserialize(value_type_code, buf);
|
||||
if let Ok(val) = val {
|
||||
value.insert(key_type_code, val);
|
||||
}
|
||||
}
|
||||
|
||||
value
|
||||
}
|
||||
|
||||
pub fn deserialize_event_data(buf: &mut Cursor<&[u8]>) -> Option<types::EventData> {
|
||||
let code = buf.get_u8();
|
||||
|
||||
Some(types::EventData {
|
||||
code,
|
||||
parameters: deserialize_parameter_table(buf),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn deserialize_operation_response(buf: &mut Cursor<&[u8]>) -> Option<types::OperationResponse> {
|
||||
let code = buf.get_u8();
|
||||
let return_code = buf.get_i16_be();
|
||||
let debug_message = if let Value::String(s) = deserialize(buf.get_u8(), buf).unwrap() {
|
||||
s
|
||||
} else {
|
||||
"None".to_owned()
|
||||
};
|
||||
let parameters = deserialize_parameter_table(buf);
|
||||
Some(types::OperationResponse {
|
||||
code,
|
||||
return_code,
|
||||
debug_message,
|
||||
parameters,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn deserialize_operation_request(buf: &mut Cursor<&[u8]>) -> Option<types::OperationRequest> {
|
||||
let code = buf.get_u8();
|
||||
|
||||
Some(types::OperationRequest {
|
||||
code,
|
||||
parameters: deserialize_parameter_table(buf),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
if size == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
for _ in 0..size {
|
||||
let type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
value.push(deserialize(type_code, buf).unwrap());
|
||||
}
|
||||
|
||||
Some(value)
|
||||
}
|
||||
|
||||
pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Result<Value, DeserializationError> {
|
||||
match TypeCode::from(type_code) {
|
||||
TypeCode::Null => Ok(Value::None),
|
||||
TypeCode::Boolean => deserialize_boolean(buf)
|
||||
.map(|v| Ok(Value::Boolean(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Byte => deserialize_byte(buf)
|
||||
.map(|v| Ok(Value::Byte(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Double => deserialize_double(buf)
|
||||
.map(|v| Ok(Value::Double(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Float => deserialize_float(buf)
|
||||
.map(|v| Ok(Value::Float(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Integer => deserialize_integer(buf)
|
||||
.map(|v| Ok(Value::Integer(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Long => deserialize_long(buf)
|
||||
.map(|v| Ok(Value::Long(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Short => deserialize_short(buf)
|
||||
.map(|v| Ok(Value::Short(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::String => deserialize_string(buf)
|
||||
.map(|v| Ok(Value::String(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::StringArray => deserialize_string_array(buf)
|
||||
.map(|v| Ok(Value::StringArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::ByteArray => deserialize_byte_array(buf)
|
||||
.map(|v| Ok(Value::ByteArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Array => deserialize_array(buf)
|
||||
.map(|v| Ok(Value::Array(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Dictionary => deserialize_dictionary(buf)
|
||||
.map(|v| Ok(Value::Dictionary(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::OperationRequest => deserialize_operation_request(buf)
|
||||
.map(|v| Ok(Value::OperationRequest(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::OperationResponse => deserialize_operation_response(buf)
|
||||
.map(|v| Ok(Value::OperationResponse(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::EventData => deserialize_event_data(buf)
|
||||
.map(|v| Ok(Value::EventData(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::ObjectArray => deserialize_object_array(buf)
|
||||
.map(|v| Ok(Value::ObjectArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
_ => Err(DeserializationError { type_code }),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn deserialize_dictionary() {
|
||||
let value = vec![
|
||||
68, 115, 115, 0, 2, 0, 8, 116, 101, 115, 116, 75, 101, 121, 49, 0, 10, 116, 101, 115,
|
||||
116, 86, 97, 108, 117, 101, 49, 0, 8, 116, 101, 115, 116, 75, 101, 121, 50, 0, 10, 116,
|
||||
101, 115, 116, 86, 97, 108, 117, 101, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Dictionary(v) => {
|
||||
return assert_eq!(
|
||||
v.get("testKey1"),
|
||||
Some(&Value::String("testValue1".to_owned()))
|
||||
)
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_string_array() {
|
||||
let value = vec![
|
||||
121, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::String(val) = &v[0] {
|
||||
assert_eq!(val, &"test1".to_owned());
|
||||
}
|
||||
if let Value::String(val) = &v[1] {
|
||||
assert_eq!(val, &"test2".to_owned());
|
||||
}
|
||||
return;
|
||||
}
|
||||
Value::StringArray(v) => {
|
||||
return assert_eq!(vec!["test1".to_owned(), "test2".to_owned()], v)
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialize_byte() {
|
||||
let value = vec![98, 6];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Byte(v) => return assert_eq!(v, 6),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_double() {
|
||||
let value = vec![100, 64, 147, 74, 51, 51, 51, 51, 51, 0, 0, 0, 0, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Double(v) => return assert_eq!(v, 1234.55),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_event_data() {
|
||||
let value = vec![
|
||||
101, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116,
|
||||
50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::EventData(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
assert_eq!(
|
||||
v.parameters.get(&0).unwrap(),
|
||||
&Value::String("test1".to_owned())
|
||||
);
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_float() {
|
||||
let value = vec![102, 68, 154, 81, 154, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Float(v) => return assert_eq!(v, 1234.55),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_integer() {
|
||||
let value = vec![105, 0, 0, 4, 210, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Integer(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_short() {
|
||||
let value = vec![107, 4, 210, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Short(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_long() {
|
||||
let value = vec![108, 0, 0, 0, 0, 0, 0, 4, 210, 0, 0, 0, 0, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Long(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_integer_array() {
|
||||
let value = vec![121, 0, 2, 105, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Integer(val) = v[0] {
|
||||
assert_eq!(val, 0);
|
||||
}
|
||||
if let Value::Integer(val) = v[1] {
|
||||
assert_eq!(val, 1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_boolean() {
|
||||
let value = vec![111, 1];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
|
||||
let type_code = buf.get_u8();
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Boolean(v) => return assert_eq!(v, true),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_operation_response() {
|
||||
let value = vec![
|
||||
112, 100, 0, 100, 42, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116,
|
||||
101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::OperationResponse(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
assert_eq!(v.return_code, 100);
|
||||
assert_eq!(
|
||||
v.parameters.get(&1).unwrap(),
|
||||
&Value::String("test2".to_owned())
|
||||
);
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_operation_request() {
|
||||
let value = vec![
|
||||
113, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116,
|
||||
50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::OperationRequest(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
assert_eq!(
|
||||
v.parameters.get(&1).unwrap(),
|
||||
&Value::String("test2".to_owned())
|
||||
);
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_string() {
|
||||
let value = vec![
|
||||
115, 0, 12, 116, 101, 115, 116, 95, 109, 101, 115, 115, 97, 103, 101, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::String(v) => return assert_eq!(&v, "test_message"),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_byte_array() {
|
||||
let value = vec![120, 0, 0, 0, 2, 6, 7, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::ByteArray(v) => {
|
||||
assert_eq!(&v[0], &6);
|
||||
assert_eq!(&v[1], &7);
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_dictionary() {
|
||||
let value = vec![
|
||||
121, 0, 1, 68, 105, 115, 0, 1, 0, 0, 0, 0, 0, 5, 116, 101, 115, 116, 49, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Dictionary(val) = &v[0] {
|
||||
assert_eq!(val.get("0").unwrap(), &Value::String("test1".to_owned()));
|
||||
}
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_byte_array() {
|
||||
let value = vec![121, 0, 1, 120, 0, 0, 0, 4, 0, 2, 4, 8, 0, 0, 0, 0];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::ByteArray(val) = &v[0] {
|
||||
assert_eq!(val[0], 0);
|
||||
assert_eq!(val[1], 2);
|
||||
assert_eq!(val[2], 4);
|
||||
assert_eq!(val[3], 8);
|
||||
return;
|
||||
}
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_array() {
|
||||
let value = vec![
|
||||
121, 0, 1, 121, 0, 3, 105, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Integer(val) = &v[0][0] {
|
||||
assert_eq!(val, &1);
|
||||
}
|
||||
if let Value::Integer(val) = &v[0][1] {
|
||||
assert_eq!(val, &2);
|
||||
}
|
||||
if let Value::Integer(val) = &v[0][2] {
|
||||
assert_eq!(val, &3);
|
||||
}
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_object_array() {
|
||||
let value = vec![
|
||||
122, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let mut buf = Cursor::new(&value[..]);
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::ObjectArray(v) => {
|
||||
if let Value::String(val) = &v[0] {
|
||||
assert_eq!(val, &"test1".to_owned());
|
||||
}
|
||||
if let Value::String(val) = &v[1] {
|
||||
assert_eq!(val, &"test2".to_owned());
|
||||
}
|
||||
}
|
||||
_ => assert!(false),
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
pub type Parameters = HashMap<u8, Value>;
|
||||
|
||||
pub enum TypeCode {
|
||||
Unknown = 0,
|
||||
Null = 42,
|
||||
Dictionary = 68,
|
||||
StringArray = 97,
|
||||
Byte = 98,
|
||||
Double = 100,
|
||||
EventData = 101,
|
||||
Float = 102,
|
||||
Integer = 105,
|
||||
Short = 107,
|
||||
Long = 108,
|
||||
BooleanArray = 110,
|
||||
Boolean = 111,
|
||||
OperationResponse = 112,
|
||||
OperationRequest = 113,
|
||||
String = 115,
|
||||
ByteArray = 120,
|
||||
Array = 121,
|
||||
ObjectArray = 122,
|
||||
}
|
||||
|
||||
impl From<u8> for TypeCode {
|
||||
fn from(v: u8) -> Self {
|
||||
match v {
|
||||
0 => TypeCode::Unknown,
|
||||
42 => TypeCode::Null,
|
||||
68 => TypeCode::Dictionary,
|
||||
97 => TypeCode::StringArray,
|
||||
98 => TypeCode::Byte,
|
||||
100 => TypeCode::Double,
|
||||
101 => TypeCode::EventData,
|
||||
102 => TypeCode::Float,
|
||||
105 => TypeCode::Integer,
|
||||
107 => TypeCode::Short,
|
||||
108 => TypeCode::Long,
|
||||
110 => TypeCode::BooleanArray,
|
||||
111 => TypeCode::Boolean,
|
||||
112 => TypeCode::OperationResponse,
|
||||
113 => TypeCode::OperationRequest,
|
||||
115 => TypeCode::String,
|
||||
120 => TypeCode::ByteArray,
|
||||
121 => TypeCode::Array,
|
||||
122 => TypeCode::ObjectArray,
|
||||
_ => TypeCode::Unknown
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct EventData {
|
||||
pub code: u8,
|
||||
pub parameters: Parameters
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OperationResponse {
|
||||
pub code: u8,
|
||||
pub return_code: i16,
|
||||
pub debug_message: String,
|
||||
pub parameters: Parameters
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OperationRequest {
|
||||
pub code: u8,
|
||||
pub parameters: Parameters
|
||||
}
|
||||
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Value {
|
||||
None,
|
||||
Dictionary(HashMap<String, Value>),
|
||||
StringArray(Vec<String>),
|
||||
Byte(u8),
|
||||
Double(f64),
|
||||
EventData(EventData),
|
||||
Float(f32),
|
||||
Integer(u32),
|
||||
Short(i16),
|
||||
Long(i64),
|
||||
BooleanArray(Vec<bool>),
|
||||
Boolean(bool),
|
||||
OperationResponse(OperationResponse),
|
||||
OperationRequest(OperationRequest),
|
||||
String(String),
|
||||
ByteArray(Vec<u8>),
|
||||
Array(Vec<Value>),
|
||||
ObjectArray(Vec<Value>)
|
||||
}
|
||||
|
||||
impl std::ops::Index<usize> for Value {
|
||||
type Output = Value;
|
||||
|
||||
fn index(&self, index: usize) -> &Self::Output {
|
||||
match self {
|
||||
Value::Array(v) => &v[index],
|
||||
_ => panic!("Non indexable type")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Value {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Value::String(v) => write!(f, "{}", v),
|
||||
Value::Byte(v) => write!(f, "{}", v),
|
||||
Value::Integer(v) => write!(f, "{}", v),
|
||||
v => write!(f, "{:?}", v)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python
|
||||
import sys
|
||||
|
||||
|
||||
from setuptools import setup
|
||||
|
||||
try:
|
||||
from setuptools_rust import RustExtension, Binding
|
||||
except ImportError:
|
||||
import subprocess
|
||||
|
||||
errno = subprocess.call([sys.executable, "-m", "pip", "install", "setuptools-rust"])
|
||||
if errno:
|
||||
print("Please install setuptools-rust package")
|
||||
raise SystemExit(errno)
|
||||
else:
|
||||
from setuptools_rust import RustExtension, Binding
|
||||
|
||||
setup_requires = ["setuptools-rust>=0.10.1", "wheel"]
|
||||
install_requires = []
|
||||
|
||||
setup(
|
||||
name="aostats",
|
||||
packages=["aostats"],
|
||||
rust_extensions=[RustExtension("libaostats", 'Cargo.toml', binding=Binding.RustCPython)],
|
||||
install_requires=install_requires,
|
||||
setup_requires=setup_requires,
|
||||
include_package_data=True,
|
||||
zip_safe=False,
|
||||
)
|
||||
@@ -0,0 +1,702 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,343 @@
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
mod packet;
|
||||
mod protocol;
|
||||
pub mod message;
|
||||
|
||||
pub use protocol::decode;
|
||||
pub use message::Message;
|
||||
@@ -0,0 +1,7 @@
|
||||
use photon_protocol::Parameters;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Packet {
|
||||
pub code: usize,
|
||||
pub parameters: Parameters
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
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
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
#[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!(libaostats, initlibaostats, PyInit_libaostats, |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(())
|
||||
});
|
||||
@@ -0,0 +1,333 @@
|
||||
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());
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
#[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<()>;
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user