Reduced backend resposibility to emmit game events, whole addon logic implemented in python side
This commit is contained in:
@@ -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();
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod python;
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod convert;
|
||||
@@ -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,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
}
|
||||
@@ -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()))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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(())
|
||||
});
|
||||
@@ -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
@@ -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());
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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<()>;
|
||||
|
||||
@@ -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),
|
||||
@@ -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![]);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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 {
|
||||
}
|
||||
Reference in New Issue
Block a user