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
+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");
}
}