Reduced backend resposibility to emmit game events, whole addon logic implemented in python side

This commit is contained in:
Wiktor Mazur
2020-02-18 16:55:33 +01:00
parent d73f34a33b
commit 133975cd77
78 changed files with 3203 additions and 1331 deletions
+59
View File
@@ -0,0 +1,59 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use photon_decode::Photon;
use crate::game::World;
use crate::publisher::Publisher;
pub use crate::publisher::Subscribers;
use crate::translate::udp_packet_to_game_events;
pub enum InitializationError {
NetworkInterfaceListMissing,
}
pub fn initialize(subscribers: Subscribers) -> Result<(), InitializationError> {
initialize_logging();
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
let mut photon = Photon::new();
let mut world = World::new();
let mut publisher = Publisher::new(subscribers);
packet_sniffer::receive(interfaces, tx);
info!("Listening to network packets...");
loop {
if let Ok(packet) = rx.recv() {
udp_packet_to_game_events(&mut world, &mut photon, &packet)
.into_iter()
.for_each(|e| {
publisher.publish(&e);
});
}
}
});
} else {
return Err(InitializationError::NetworkInterfaceListMissing);
}
Ok(())
}
fn initialize_logging() {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Info,
Config::default(),
File::create("damage-meter.log").unwrap(),
)]).unwrap();
}
-639
View File
@@ -1,639 +0,0 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use photon_decode;
use photon_decode::Photon;
use crate::game_messages;
use crate::meter;
pub use meter::GameStats;
pub use meter::LastFightStats;
pub use meter::MeterConfig;
pub use meter::OverallStats;
pub use meter::PlayerEvents;
pub use meter::PlayerStatistics;
pub use meter::PlayerStatisticsVec;
pub use meter::ZoneStats;
pub use meter::StatType;
pub use crate::game_messages::Items;
pub enum InitializationError {
NetworkInterfaceListMissing,
}
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 initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
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();
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
let mut photon = Photon::new();
packet_sniffer::receive(interfaces, tx);
info!("Listening to network packets...");
loop {
if let Ok(packet) = rx.recv() {
if packet.destination_port != 5056 && packet.source_port != 5056 {
continue;
}
if let Ok(ref mut meter) = cloned_meter.lock() {
let game_messages = photon
.decode(&packet.payload)
.into_iter()
.filter_map(game_messages::into_game_message)
.collect();
register_messages(meter, &game_messages);
}
}
}
});
} else {
return Err(InitializationError::NetworkInterfaceListMissing);
}
Ok(meter)
}
pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_messages::Message>) {
messages
.iter()
.for_each(|message| register_message(meter, &message));
}
fn register_message<Events>(events: &mut Events, message: &game_messages::Message)
where
Events: PlayerEvents,
{
info!("Found message {:?}", message);
match message {
game_messages::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()),
game_messages::Message::NewCharacter(msg) => {
events.register_player(&msg.character_name, msg.source);
events.register_item_update(msg.source, &msg.items);
},
game_messages::Message::CharacterEquipmentChanged(msg) => {
events.register_item_update(msg.source, &msg.items);
},
game_messages::Message::Join(msg) => {
events.register_main_player(&msg.character_name, msg.source)
}
game_messages::Message::HealthUpdate(msg) => events
.register_damage_dealt(msg.target, msg.value)
.unwrap_or(()),
game_messages::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_messages::Message::KnockedDown(msg) => events.register_combat_leave(msg.source).unwrap_or(()),
game_messages::Message::UpdateFame(msg) => events
.register_fame_gain(msg.source, msg.fame as f32 / 10000.0)
.unwrap_or(()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use game_messages::messages;
use game_messages::Items;
use game_messages::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 messages::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,
items: Items::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
}
}
}
impl NamedTesting for messages::Join {
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 messages::NewCharacter {
fn new(source: usize) -> Self {
messages::NewCharacter::new_named("CH1", source)
}
}
impl Testing for messages::Join {
fn new(source: usize) -> Self {
messages::Join::new_named("MAIN_CH1", source)
}
}
impl Testing for messages::Leave {
fn new(source: usize) -> Self {
Self { source: source }
}
}
impl Testing for messages::HealthUpdate {
fn new(source: usize) -> Self {
Self {
source: 200,
target: source,
value: -10.0,
}
}
}
impl Testing for messages::UpdateFame {
fn new(source: usize) -> Self {
Self {
source: source,
fame: 1000000,
}
}
}
impl SwitchableTesting for messages::RegenerationHealthChanged {
fn enabled(source: usize) -> Self {
Self {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: Some(1.0),
}
}
fn disabled(source: usize) -> Self {
Self {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: None,
}
}
}
#[test]
fn test_empty_session() {
let 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(messages::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(messages::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(messages::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(
&mut meter,
&Message::HealthUpdate(messages::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(messages::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(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::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(messages::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(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::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::Join(messages::Join::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(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
register_message(
&mut meter,
&Message::Join(messages::Join::new(2)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(2)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::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::Join(messages::Join::new_named($name, $id)),
);
};
}
macro_rules! character_enters {
($meter:expr, $name:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::NewCharacter(messages::NewCharacter::new_named($name, $id)),
);
};
}
macro_rules! attack {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(
$id,
)),
);
register_message(
&mut $meter,
&Message::HealthUpdate(messages::HealthUpdate::new($id)),
);
};
}
macro_rules! combat_leave {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(messages::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", 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);
register_message(&mut meter, &Message::Leave(messages::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);
}
#[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::UpdateFame(messages::UpdateFame::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);
}
}
+1
View File
@@ -0,0 +1 @@
pub mod python;
+142
View File
@@ -0,0 +1,142 @@
use cpython::PyObject;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::PyDict;
use crate::game::Event;
use crate::game::events;
use crate::game::StaticId;
use crate::photon_messages;
impl ToPyObject for Event {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
match self {
Event::MainPlayerAppeared(e) => {
event.set_item(py, "name", "MainPlayerAppeared".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
},
Event::PlayerAppeared(e) => {
event.set_item(py, "name", "PlayerAppeared".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
},
Event::ZoneChange => {
event.set_item(py, "name", "ZoneChange".into_py_object(py)).unwrap_or(());
},
Event::UpdateItems(e) => {
event.set_item(py, "name", "UpdateItems".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::DamageDone(e) => {
event.set_item(py, "name", "DamageDone".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::EnterCombat(e) => {
event.set_item(py, "name", "EnterCombat".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::LeaveCombat(e) => {
event.set_item(py, "name", "LeaveCombat".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::UpdateFame(e) => {
event.set_item(py, "name", "UpdateFame".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::HealthReceived(e) => {
event.set_item(py, "name", "HealthReceived".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
}
event.into_object()
}
}
impl ToPyObject for StaticId {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
self.inner().into_py_object(py).into_object()
}
}
impl ToPyObject for events::Player {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "id", self.id.into_py_object(py)).unwrap_or(());
event.set_item(py, "name", self.name.clone().into_py_object(py)).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Damage {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "target", self.target.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Fame {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Items {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.clone().into_py_object(py)).unwrap_or(());
event.into_object()
}
}
macro_rules! set_dict_item {
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
{}
};
}
impl ToPyObject for photon_messages::Items {
type ObjectType = PyDict;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.to_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let items = PyDict::new(py);
set_dict_item!(py, items, self, weapon);
set_dict_item!(py, items, self, offhand);
set_dict_item!(py, items, self, helmet);
set_dict_item!(py, items, self, armor);
set_dict_item!(py, items, self, boots);
set_dict_item!(py, items, self, bag);
set_dict_item!(py, items, self, cape);
set_dict_item!(py, items, self, mount);
set_dict_item!(py, items, self, potion);
set_dict_item!(py, items, self, food);
items
}
}
+1
View File
@@ -0,0 +1 @@
pub mod convert;
+133
View File
@@ -0,0 +1,133 @@
use std::convert::From;
use crate::photon_messages::messages;
use super::events;
use super::player::{StaticId, PlayerName};
pub struct EventIntermediate<Msg> {
id: StaticId,
name: PlayerName,
message: Msg,
}
impl<Msg> EventIntermediate<Msg> {
pub fn new(
id: StaticId,
name: PlayerName,
message: Msg,
) -> Self {
Self {
id,
name,
message,
}
}
}
pub struct EventList {
value: Vec<events::Event>,
}
impl EventList {
pub fn new(list: Vec<events::Event>) -> Self {
Self { value: list }
}
pub fn values(self) -> Vec<events::Event> {
self.value
}
}
impl From<EventIntermediate<messages::NewCharacter>> for events::Event {
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
Self::PlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
})
}
}
impl From<EventIntermediate<messages::NewCharacter>> for EventList {
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
Self::new(vec![
events::Event::PlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
}),
events::Event::UpdateItems(events::Items {
source: intermediate.id,
value: intermediate.message.items,
}),
])
}
}
impl From<EventIntermediate<messages::Join>> for events::Event {
fn from(intermediate: EventIntermediate<messages::Join>) -> Self {
Self::MainPlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
})
}
}
impl From<EventIntermediate<messages::HealthUpdate>> for events::Event {
fn from(intermediate: EventIntermediate<messages::HealthUpdate>) -> Self {
if intermediate.message.value < 0.0 {
return Self::DamageDone(events::Damage {
source: intermediate.id,
target: None,
value: f32::abs(intermediate.message.value),
});
}
Self::HealthReceived(events::Damage {
source: intermediate.id,
target: None,
value: intermediate.message.value,
})
}
}
impl From<EventIntermediate<messages::RegenerationHealthChanged>> for events::Event {
fn from(intermediate: EventIntermediate<messages::RegenerationHealthChanged>) -> Self {
match intermediate.message.regeneration_rate {
Some(_) => Self::LeaveCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
}),
None => Self::EnterCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
}),
}
}
}
impl From<EventIntermediate<messages::KnockedDown>> for events::Event {
fn from(intermediate: EventIntermediate<messages::KnockedDown>) -> Self {
Self::LeaveCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
})
}
}
impl From<EventIntermediate<messages::UpdateFame>> for events::Event {
fn from(intermediate: EventIntermediate<messages::UpdateFame>) -> Self {
Self::UpdateFame(events::Fame {
source: intermediate.id,
value: intermediate.message.fame as f32 / 10000.0,
})
}
}
impl From<EventIntermediate<messages::CharacterEquipmentChanged>> for events::Event {
fn from(intermediate: EventIntermediate<messages::CharacterEquipmentChanged>) -> Self {
Self::UpdateItems(events::Items {
source: intermediate.id,
value: intermediate.message.items,
})
}
}
+43
View File
@@ -0,0 +1,43 @@
#![allow(dead_code)]
use crate::photon_messages;
use super::player::StaticId;
#[derive(Debug, Clone, PartialEq)]
pub struct Player {
pub id: StaticId,
pub name: String,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Damage {
pub source: StaticId,
pub target: Option<StaticId>,
pub value: f32,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Fame {
pub source: StaticId,
pub value: f32,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Items {
pub source: StaticId,
pub value: photon_messages::Items,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Event {
MainPlayerAppeared(Player),
PlayerAppeared(Player),
DamageDone(Damage),
HealthReceived(Damage),
ZoneChange,
EnterCombat(Player),
LeaveCombat(Player),
UpdateFame(Fame),
UpdateItems(Items),
}
+112
View File
@@ -0,0 +1,112 @@
#![allow(dead_code)]
use bimap::BiMap;
use std::collections::HashMap;
use super::player::{StaticId, DynamicId, PlayerName};
#[derive(Debug, PartialEq, Default)]
pub struct IdCache {
name_to_static_id: HashMap<String, u32>,
dyn_id_to_name: BiMap<u32, String>,
last_id: u32,
}
impl IdCache {
pub fn new() -> Self {
Self {
..Default::default()
}
}
pub fn save(&mut self, dynamic_id: DynamicId, name: &str) {
if self.name_to_static_id.get(name).is_none() {
let id = self.last_id;
self.last_id += 1;
self.name_to_static_id.insert(name.to_owned(), id);
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
}
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
}
pub fn get_static_id(&self, dynamic_id: DynamicId) -> Option<StaticId> {
self.dyn_id_to_name
.get_by_left(&dynamic_id.into())
.map(|name| {
self.name_to_static_id
.get(name)
.map(|v| *v)
.map(|v| v.into())
})
.flatten()
}
pub fn get_name(&self, static_id: StaticId) -> Option<PlayerName> {
self.name_to_static_id
.iter()
.find(|(_k, v)| **v == StaticId::into(static_id))
.map(|v| v.0)
.map(|v| v.clone().into())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_id_cache() {
let mut cache = IdCache::new();
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
cache.save(DynamicId::from(1), "test");
assert!(cache.get_static_id(DynamicId::from(1)).is_some());
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
cache.save(DynamicId::from(2), "test");
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(0)));
}
#[test]
fn test_if_id_is_unique_for_a_player() {
let mut cache = IdCache::new();
cache.save(DynamicId::from(1), "test");
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
cache.save(DynamicId::from(2), "test2");
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
cache.save(DynamicId::from(12345), "test3");
assert_eq!(cache.get_static_id(DynamicId::from(12345)), Some(StaticId::from(2)));
}
#[test]
fn test_finding_player_name() {
let mut cache = IdCache::new();
assert!(cache.get_name(StaticId::from(1)).is_none());
cache.save(DynamicId::from(1), "test");
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
assert_eq!(
cache.get_name(StaticId::from(0)),
Some(PlayerName::from("test".to_owned()))
);
cache.save(DynamicId::from(2), "test2");
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
assert_eq!(
cache.get_name(StaticId::from(1)),
Some(PlayerName::from("test2".to_owned()))
);
assert_eq!(
cache.get_name(StaticId::from(0)),
Some(PlayerName::from("test".to_owned()))
);
}
}
+11
View File
@@ -0,0 +1,11 @@
pub mod events;
pub mod convert;
pub mod world;
pub mod id_cache;
mod unconsumed_messages;
mod player;
pub use player::StaticId;
pub use events::*;
pub use world::World;
+16
View File
@@ -0,0 +1,16 @@
use derive_more::{From, Into};
#[derive(Copy, Clone, Debug, PartialEq, From, Into, Default)]
pub struct DynamicId(u32);
#[derive(Copy, Clone, Debug, PartialEq, From, Into)]
pub struct StaticId(u32);
#[derive(Debug, PartialEq, From, Into, Default)]
pub struct PlayerName(String);
impl StaticId {
pub fn inner(&self) -> u32 {
self.0
}
}
+23
View File
@@ -0,0 +1,23 @@
use super::player::{DynamicId};
use crate::photon_messages::Message;
use std::collections::HashMap;
#[derive(Debug, PartialEq, Default)]
pub struct UnconsumedMessages{
messages: HashMap<u32, Vec<Message>>
}
impl UnconsumedMessages {
pub fn add(&mut self, msg: Message, id: DynamicId) {
self.messages.entry(id.into()).or_insert(vec![]).push(msg);
}
pub fn get_for_id(&mut self, id: DynamicId) -> Option<Vec<Message>> {
let messages = self.messages.get(&id.into())?;
let result = messages.clone();
self.messages.remove(&id.into());
return Some(result);
}
}
+333
View File
@@ -0,0 +1,333 @@
//! Holds state of the game gathered from photon decoded packets.
//! Note: This module is responsible for resolving all inconsistency between photon events and required game events.
//!
//! Inconsistency list:
//! - player id is different in each zone
use crate::photon_messages;
use super::events;
use super::convert;
use super::convert::EventList;
use super::id_cache;
use super::player::{StaticId, DynamicId};
use super::unconsumed_messages::UnconsumedMessages;
#[derive(Debug, Default)]
pub struct World {
cache: id_cache::IdCache,
unconsumed_messages: UnconsumedMessages,
main_player_id: Option<StaticId>,
}
impl World {
pub fn new() -> Self {
Self {
..Default::default()
}
}
/// Transforms inconsistent game message into corresponding list of game events
pub fn transform(
&mut self,
message: photon_messages::Message,
) -> Option<Vec<events::Event>> {
match message {
photon_messages::Message::NewCharacter(msg) => {
let mut result = vec![];
let dynamic_id = DynamicId::from(msg.source as u32);
self.assign_dynamic_id(dynamic_id, &msg.character_name);
let static_id = self.get_static_id(msg.source)?;
result.append(&mut EventList::from(self.get_intermediate(static_id, msg)?).values());
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
for message in messages {
result.append(&mut self.transform(message).unwrap_or(vec![]));
}
}
Some(result)
}
photon_messages::Message::Join(msg) => {
let mut result = vec![];
let dynamic_id = DynamicId::from(msg.source as u32);
self.assign_dynamic_id(dynamic_id, &msg.character_name);
let static_id = self.get_static_id(msg.source)?;
if self.main_player_id.is_none() {
result.push(events::Event::ZoneChange)
}
result.push(self.get_intermediate(static_id, msg)?.into());
self.main_player_id = Some(static_id);
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
for message in messages {
result.append(&mut self.transform(message).unwrap_or(vec![]));
}
}
Some(result)
}
photon_messages::Message::Leave(msg) => {
let static_id = self.get_static_id(msg.source)?;
if let Some(main_player_id) = self.main_player_id {
if main_player_id == static_id {
return Some(vec![events::Event::ZoneChange]);
}
}
None
}
photon_messages::Message::HealthUpdate(msg) => {
let static_id = self.get_static_id(msg.target)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::RegenerationHealthChanged(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::KnockedDown(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::UpdateFame(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::CharacterEquipmentChanged(msg) => {
if let Some(static_id) = self.get_static_id(msg.source) {
return Some(vec![self.get_intermediate(static_id, msg)?.into()]);
}
let id = DynamicId::from(msg.source as u32);
self.unconsumed_messages.add(
photon_messages::messages::Message::CharacterEquipmentChanged(msg), id);
None
}
}
}
fn assign_dynamic_id(&mut self, id: DynamicId, name: &str) {
self.cache.save(id, name);
}
fn get_static_id(&self, id: usize) -> Option<StaticId> {
let dynamic_id = DynamicId::from(id as u32);
self.cache.get_static_id(dynamic_id) // queue message if static id isn't known
}
fn get_intermediate<Msg>(
&self,
static_id: StaticId,
msg: Msg,
) -> Option<convert::EventIntermediate<Msg>> {
Some(convert::EventIntermediate::new(
static_id,
self.cache.get_name(static_id)?,
msg,
))
}
}
#[cfg(test)]
mod tests {
use super::*;
macro_rules! assert_contains {
($container:expr, $value:expr) => {
assert!(
format!("{:?}", $container).contains($value),
format!("{:?} does not contains {}", $container, $value)
);
};
}
macro_rules! simulate_new_player {
($id:expr, $name:expr, $msg:ident) => {
photon_messages::Message::$msg(photon_messages::messages::$msg {
source: $id,
character_name: $name.to_string(),
..Default::default()
});
};
}
#[test]
/// photon_messages::NewCharacter -> events::Event::PlayerAppeared
fn test_player_appeared() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", NewCharacter);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
}
#[test]
/// photon_messages::Join -> Event::PlayerAppeared
fn test_main_player_appeared() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
}
#[test]
/// photon_messages::HealthUpdate -> Event::DamageDone | Event::HealthReceived
fn test_damage_done() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
let target = 1;
let game_message =
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
target,
value: -666.0,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(world.transform(game_message.clone()), "DamageDone");
assert_contains!(world.transform(game_message.clone()), "-666");
let target = 1;
let game_message =
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
target,
value: 666.0,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"HealthReceived"
);
assert_contains!(world.transform(game_message.clone()), "666");
}
#[test]
/// photon_messages::Leave -> Event::ZoneChange
fn test_zone_change() {
let mut world = World::new();
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_none());
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "ZoneChange");
let game_message = simulate_new_player!(2, "TestCharacter", NewCharacter);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_none());
}
#[test]
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::LeaveCombat
fn test_combat_leave_via_regeneration_change() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::RegenerationHealthChanged(
photon_messages::messages::RegenerationHealthChanged {
source: 1,
regeneration_rate: Some(1.0),
..Default::default()
},
);
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
}
#[test]
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::EnterCombat
fn test_combat_enter_via_regeneration_change() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::RegenerationHealthChanged(
photon_messages::messages::RegenerationHealthChanged {
source: 1,
regeneration_rate: None,
..Default::default()
},
);
assert_contains!(world.transform(game_message.clone()), "EnterCombat");
}
#[test]
/// photon_messages::KnockedDown -> Event::EnterCombat
fn test_combat_enter_via_knockout() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message =
photon_messages::Message::KnockedDown(photon_messages::messages::KnockedDown {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
}
#[test]
/// photon_messages::UpdateFame -> Event::FameUpdate
fn test_fame_update() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message =
photon_messages::Message::UpdateFame(photon_messages::messages::UpdateFame {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "UpdateFame");
}
}
-200
View File
@@ -1,200 +0,0 @@
#[macro_use]
extern crate cpython;
#[macro_use]
extern crate lazy_static;
pub mod game_messages;
mod meter;
mod core;
use std::sync::{Mutex, Arc};
use log::*;
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;
use crate::core::InitializationError;
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());
}
macro_rules! set_dict_item {
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
{}
};
}
impl ToPyObject for core::PlayerStatistics {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let stats = PyDict::new(py);
set_dict_item!(py, stats, self, player);
set_dict_item!(py, stats, self, damage);
set_dict_item!(py, stats, self, time_in_combat);
set_dict_item!(py, stats, self, dps);
set_dict_item!(py, stats, self, seconds_in_game);
set_dict_item!(py, stats, self, fame);
set_dict_item!(py, stats, self, fame_per_minute);
set_dict_item!(py, stats, self, fame_per_hour);
set_dict_item!(py, stats, self, items);
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 ToPyObject for core::Items {
type ObjectType = PyDict;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.to_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let items = PyDict::new(py);
set_dict_item!(py, items, self, weapon);
set_dict_item!(py, items, self, offhand);
set_dict_item!(py, items, self, helmet);
set_dict_item!(py, items, self, armor);
set_dict_item!(py, items, self, boots);
set_dict_item!(py, items, self, bag);
set_dict_item!(py, items, self, cape);
set_dict_item!(py, items, self, mount);
set_dict_item!(py, items, self, potion);
set_dict_item!(py, items, self, food);
items
}
}
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<PyDict> {
let stats = PyDict::new(py);
if let Ok(ref mut py_meter) = METER.lock() {
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
let mut main : Option<core::PlayerStatistics> = None;
stats.set_item(py, "players", core::stats(&meter, stat_type)
.into_iter()
.inspect(|s| {
if s.main_player_stats {
main = Some(s.clone());
}
})
.filter(|s| !s.idle || s.fame != 0.0)
.collect::<Vec<meter::PlayerStatistics>>()
.into_py_object(py)).ok();
stats.set_item(py, "main", main.into_py_object(py)).ok();
return Ok(stats);
}
}
}
error!("Failed to acquire locks on meter");
Ok(stats)
}
pub fn reset(_py: Python, stat_type: StatType) -> PyResult<u32> {
if let Ok(ref mut py_meter) = METER.lock() {
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
core::reset(meter, stat_type);
return Ok(0);
}
}
}
error!("Failed to acquire locks on meter");
Ok(1)
}
fn initialize(_py: Python) -> PyResult<u32> {
if let Ok(ref mut py_meter) = METER.lock() {
match core::initialize() {
Ok(core_meter) => py_meter.initialize(core_meter),
Err(InitializationError::NetworkInterfaceListMissing) => return Ok(2)
};
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
meter.configure(core::MeterConfig {
..Default::default()
});
return Ok(0);
}
}
}
error!("Failed to initialize meter");
Ok(1)
}
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()))?;
m.add(py, "stats", py_fn!(py, stats(stat_type: StatType)))?;
m.add(py, "reset", py_fn!(py, reset(stat_type: StatType)))?;
Ok(())
});
+64
View File
@@ -0,0 +1,64 @@
#[macro_use]
extern crate cpython;
#[macro_use]
extern crate lazy_static;
mod photon_messages;
mod game;
mod translate;
mod publisher;
mod crosslang;
mod api;
use std::sync::Mutex;
use log::*;
use cpython::PyResult;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::ObjectProtocol;
use cpython::PyTuple;
lazy_static! {
static ref PY_CALLBACKS: Mutex<Vec<cpython::PyObject>> = Mutex::new(Vec::new());
}
fn python_callbacks_subscriber(event: game::Event) {
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
let gil = Python::acquire_gil();
let py = gil.python();
for py_callback in py_callbacks.iter() {
let py_args = [event.clone().into_py_object(py).into_object()];
let args = PyTuple::new(py, &py_args[..]);
if let Some(error) = py_callback.call(py, args, None).err() {
error!("{:?}", error);
}
}
}
}
fn initialize(_py: Python) -> PyResult<u32> {
api::initialize(vec![
Box::new(python_callbacks_subscriber)
]).map_or(Ok(0), |_| {Ok(2)})
}
fn subscribe(_py: Python, callable: cpython::PyObject) -> PyResult<u32> {
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
py_callbacks.push(callable);
}
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()))?;
m.add(py, "subscribe", py_fn!(py, subscribe(callable: cpython::PyObject)))?;
Ok(())
});
+122 -134
View File
@@ -10,9 +10,10 @@ mod traits;
mod types;
mod session;
use crate::game::Event;
use player::Player;
pub use super::game_messages;
use super::photon_messages;
pub use traits::*;
pub use types::*;
@@ -21,29 +22,138 @@ use session::Session;
#[derive(Default)]
pub struct MeterConfig {}
#[derive(Default)]
pub struct Meter {
zone_history: PlayerStatisticsVec,
zone_session: Option<Session>,
last_fight_session: Session,
main_player_id: Option<usize>,
unconsumed_items: HashMap<usize, game_messages::Items>,
config: MeterConfig,
unconsumed_items: HashMap<usize, photon_messages::Items>,
}
impl Meter {
pub fn new() -> Self {
Self {
zone_history: PlayerStatisticsVec::new(),
zone_session: None,
last_fight_session: Session::new(),
main_player_id: None,
unconsumed_items: HashMap::new(),
config: Default::default(),
..Default::default()
}
}
pub fn configure(&mut self, config: MeterConfig) {
self.config = config;
pub fn consume(&mut self, event: Event) -> Option<()> {
match event {
Event::MainPlayerAppeared(e) => {
let id = u32::from(e.id) as usize;
self.register_player(&e.name, id, true);
if let Some(items) = self.unconsumed_items.get(&id) {
let i = items.clone();
self.register_item_update(id, &i);
self.unconsumed_items.remove(&id);
}
},
Event::PlayerAppeared(e) => {
let id = u32::from(e.id) as usize;
self.register_player(&e.name, id, false);
if let Some(items) = self.unconsumed_items.get(&id) {
let i = items.clone();
self.register_item_update(id, &i);
self.unconsumed_items.remove(&id);
}
},
Event::ZoneChange => {
self.new_session();
},
Event::UpdateItems(e) => {
let player_id = u32::from(e.source) as usize;
let items = e.value;
let mut consumed = false;
for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) {
player.items_update(&items);
consumed = true;
}
if !consumed {
info!("Storing not consumed items for player id: {}", player_id);
self.unconsumed_items.insert(player_id, items.clone());
}
}
Event::DamageDone(e) => {
let player_id = u32::from(e.source) as usize;
for player in self.get_players_in_the_zone(player_id)? {
player.register_damage_dealt(f32::abs(e.value));
}
}
Event::EnterCombat(e) => {
let player_id = u32::from(e.id) as usize;
if self.combat_state() == CombatState::OutOfCombat {
self.last_fight_session = Session::from(&self.last_fight_session);
}
for player in self.get_players_in_the_zone(player_id)? {
player.enter_combat();
}
}
Event::LeaveCombat(e) => {
let player_id = u32::from(e.id) as usize;
for player in self.get_players_in_the_zone(player_id)? {
player.leave_combat();
}
}
Event::UpdateFame(e) => {
let player_id = u32::from(e.source) as usize;
for player in self.get_players_in_the_zone(player_id)? {
player.register_fame_gain(e.value);
}
}
_ => {}
}
Some(())
}
fn get_players_in_the_zone(
&mut self,
player_id: usize,
) -> Option<Vec<&mut Player>> {
let (zone, last_fight) = self.sessions_mut()?;
let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
let zone_player = zone.get_player_by_id(player_id)?;
Some(vec![zone_player, las_fight_session_player])
}
fn register_player(&mut self, name: &str, id: usize, main: bool) {
if self.zone_session.is_none() {
info!(
"New player ({}) registered without session, creating new session",
name
);
self.new_session();
}
if self
.get_players_in_the_zone(id)
.unwrap_or(vec![])
.is_empty()
{
self.add_player(name, id, main);
}
}
fn register_item_update(
&mut self,
player_id: usize,
items: &photon_messages::Items,
) -> Option<()> {
let mut consumed = false;
for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) {
player.items_update(items);
consumed = true;
}
if !consumed {
info!("Storing not consumed items for player id: {}", player_id);
self.unconsumed_items.insert(player_id, items.clone());
}
Some(())
}
fn stats_filter(&self, _player: &(&String, &Player)) -> bool {
@@ -90,7 +200,6 @@ impl Meter {
self.last_fight_session = Session::new();
}
#[allow(unused)]
fn combat_state(&self) -> CombatState {
if self
.last_fight_session
@@ -105,117 +214,6 @@ impl Meter {
}
}
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_item_carriers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn ItemCarrier>> {
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_item_update(
&mut self,
player_id: usize,
items: &game_messages::Items,
) -> Option<()> {
let mut consumed = false;
for player in self.get_item_carriers_in_zone(player_id).unwrap_or(vec![]) {
player.items_update(items);
consumed = true;
}
if !consumed {
info!("Storing not consumed items for player id: {}", player_id);
self.unconsumed_items.insert(player_id, items.clone());
}
Some(())
}
fn 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, true);
if let Some(items) = self.unconsumed_items.get(&id) {
let i = items.clone();
self.register_item_update(id, &i);
self.unconsumed_items.remove(&id);
}
}
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();
}
if self
.get_damage_dealers_in_zone(id)
.unwrap_or(vec![])
.is_empty()
{
self.add_player(name, id, false);
}
}
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;
@@ -266,13 +264,3 @@ impl GameStats for Meter {
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());
}
+1 -1
View File
@@ -3,7 +3,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use super::game_messages::Items;
use super::photon_messages::Items;
use super::traits::CombatState;
use super::traits::DamageDealer;
+1 -13
View File
@@ -12,7 +12,7 @@ use super::player::Player;
use super::traits::CombatState;
use super::types::PlayerStatisticsVec;
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct Session {
players: HashMap<String, Player>,
}
@@ -62,18 +62,6 @@ impl Session {
)
}
pub fn cleanup_players(&mut self) {
let without_dmg = self
.players
.iter()
.filter(|(_, player)| !player.main() && player.damage() == 0.0 && player.fame() == 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()
}
+1 -51
View File
@@ -4,7 +4,7 @@ use fake_clock::FakeClock as Instant;
use std::time::Instant;
use super::types::PlayerStatisticsVec;
use super::game_messages::Items;
use super::photon_messages::Items;
#[derive(Debug, PartialEq)]
pub enum CombatState {
@@ -61,56 +61,6 @@ pub trait ItemCarrier {
fn items(&self) -> Items;
}
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 get_item_carriers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn ItemCarrier>>;
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_item_update(&mut self, player_id: usize, items: &Items) -> Option<()>;
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<()>;
+2 -2
View File
@@ -5,7 +5,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))]
use std::time::Instant;
use super::game_messages::Items;
use super::photon_messages::Items;
use super::traits::DamageStats;
use super::traits::FameStats;
@@ -24,7 +24,7 @@ pub struct PlayerStatistics {
pub main_player_stats: bool,
}
#[derive(Debug, PartialEq, Clone)]
#[derive(Debug, PartialEq, Clone, Default)]
pub struct PlayerStatisticsVec {
_vec: Vec<PlayerStatistics>,
}
@@ -1,5 +1,5 @@
use log::*;
use crate::game_messages::Items;
use crate::photon_messages::Items;
use photon_decode::Parameters;
use photon_decode::Value;
@@ -114,7 +114,7 @@ macro_rules! decode_float {
};
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Leave {
pub source: usize,
@@ -130,7 +130,7 @@ impl Leave {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct HealthUpdate {
pub source: usize,
pub target: usize,
@@ -150,7 +150,7 @@ impl HealthUpdate {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct RegenerationHealthChanged {
pub source: usize,
pub health: f32,
@@ -172,7 +172,7 @@ impl RegenerationHealthChanged {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct KnockedDown {
pub source: usize,
pub target: usize,
@@ -192,7 +192,7 @@ impl KnockedDown {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct NewCharacter {
pub source: usize,
pub character_name: String,
@@ -221,7 +221,7 @@ impl NewCharacter {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct UpdateFame {
pub source: usize,
pub fame: usize,
@@ -239,7 +239,7 @@ impl UpdateFame {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CharacterEquipmentChanged {
pub source: usize,
pub items: Items,
@@ -258,7 +258,7 @@ impl CharacterEquipmentChanged {
}
}
#[derive(Debug, Default)]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Join {
pub source: usize,
pub character_name: String,
@@ -284,7 +284,7 @@ impl Join {
}
}
#[derive(Debug)]
#[derive(Debug, Clone, PartialEq)]
pub enum Message {
Leave(Leave),
HealthUpdate(HealthUpdate),
+49
View File
@@ -0,0 +1,49 @@
use crate::game::Event;
pub type Subscriber = dyn FnMut(Event) + Send;
pub type Subscribers = Vec<Box<Subscriber>>;
#[derive(Default)]
pub struct Publisher {
subscribers: Subscribers
}
impl Publisher {
pub fn new(subscribers: Subscribers) -> Self {
Self {subscribers, ..Default::default()}
}
pub fn publish(&mut self, event: &Event) {
for subscriber in &mut self.subscribers {
subscriber(event.clone());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::thread;
#[test]
fn test_simple_subscription() {
let subscriber = |_| {};
let mut publisher = Publisher::new(vec![Box::new(subscriber)]);
publisher.publish(&Event::ZoneChange);
}
pub fn test_call_in_the_thread(subscribers: Subscribers)
{
thread::spawn(move || {
let mut publisher = Publisher::new(subscribers);
});
}
#[test]
fn test_threads() {
test_call_in_the_thread(vec![]);
}
}
+42
View File
@@ -0,0 +1,42 @@
use packet_sniffer::UdpPacket;
use photon_decode::Photon;
use crate::game::Event;
use crate::photon_messages::into_game_message;
use crate::photon_messages::Message;
use crate::game::World;
use log::*;
static GAME_PORT : u16 = 5056;
pub fn udp_packet_to_game_events(game_world: &mut World, photon: &mut Photon, packet: &UdpPacket) -> Vec<Event> {
if ! is_packet_valid(packet) {
return vec![]
}
debug!("Raw payload: {:?}", &packet.payload);
raw_to_photon_messages(photon, &packet.payload)
.into_iter()
.map(|message| game_world.transform(message))
.flatten()
.flatten()
.collect()
}
fn raw_to_photon_messages(photon: &mut Photon, packet_payload: &[u8]) -> Vec<Message> {
return photon
.decode(packet_payload)
.into_iter()
.filter_map(into_game_message)
.collect()
}
fn is_packet_valid(packet: &UdpPacket) -> bool {
return packet.destination_port == GAME_PORT || packet.source_port == GAME_PORT;
}
#[cfg(test)]
mod tests {
}