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
+1
View File
@@ -7,6 +7,7 @@ damage-meter.log
# Python # Python
.tox
.pytest_cache .pytest_cache
*.spec *.spec
env env
+4 -4
View File
@@ -8,8 +8,8 @@ jobs:
- sudo apt-get install python3-venv - sudo apt-get install python3-venv
- python3 -m venv env - python3 -m venv env
- . env/bin/activate - . env/bin/activate
- pip install -v -r frontend/requirements.txt - pip install -v -r application/requirements.txt
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data frontend/src/assets:src/assets frontend/albion-online-stats.py - pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data application/src/assets:src/assets application/albion-online-stats.py
- deactivate - deactivate
before_deploy: before_deploy:
- cp dist/albion-online-stats albion-online-stats-linux - cp dist/albion-online-stats albion-online-stats-linux
@@ -26,8 +26,8 @@ jobs:
script: script:
- python3 -m venv env - python3 -m venv env
- . env/bin/activate - . env/bin/activate
- pip install -v -r frontend/requirements.txt - pip install -v -r application/requirements.txt
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data frontend/src/assets:src/assets frontend/albion-online-stats.py - pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data application/src/assets:src/assets application/albion-online-stats.py
- deactivate - deactivate
before_deploy: before_deploy:
- cp dist/albion-online-stats albion-online-stats-osx - cp dist/albion-online-stats albion-online-stats-osx
+5 -5
View File
@@ -69,26 +69,26 @@ After first execution the app is going to create default configuration file name
or alternatively using conda and skip installing requirements step or alternatively using conda and skip installing requirements step
```shell ```shell
conda env create --file frontend/environment.yml conda env create --file application/environment.yml
conda activate albion conda activate albion
``` ```
3. Install requirements (backend will be compiled during requirements installation) 3. Install requirements (backend will be compiled during requirements installation)
```shell ```shell
pip install -v -r frontend/requirements.txt pip install -v -r application/requirements.txt
``` ```
4. Run the application 4. Run the application
```shell ```shell
[sudo on linux] python frontend/albion-online-stats.py [sudo on linux] python application/albion-online-stats.py
``` ```
## GUI testing ## GUI testing
- Seting TESTING variable runs frontend without backend dependency - Seting TESTING variable runs application without backend dependency
```shell ```shell
TESTING=true python frontend/albion-online-stats.py TESTING=true python application/albion-online-stats.py
``` ```
# License # License
+4
View File
@@ -0,0 +1,4 @@
from . import utils
from .gui.app import run

Before

Width:  |  Height:  |  Size: 2.2 KiB

After

Width:  |  Height:  |  Size: 2.2 KiB

Before

Width:  |  Height:  |  Size: 785 B

After

Width:  |  Height:  |  Size: 785 B

Before

Width:  |  Height:  |  Size: 835 B

After

Width:  |  Height:  |  Size: 835 B

Before

Width:  |  Height:  |  Size: 648 B

After

Width:  |  Height:  |  Size: 648 B

+86
View File
@@ -0,0 +1,86 @@
try:
import aostats
except:
class aostats:
@staticmethod
def initialize(_):
return InitializationResult.NetworkInterfaceListMissing
@staticmethod
def subscribe(_):
pass
from .environment import TEST_ENV_ENABLED
class InitializationResult:
Ok = 0
UnknownFailure = 1
NetworkInterfaceListMissing = 2
INITIALIZATION_RESULT = {
0: InitializationResult.Ok,
1: InitializationResult.UnknownFailure,
2: InitializationResult.NetworkInterfaceListMissing
}
def initialize():
if TEST_ENV_ENABLED:
return InitializationResult.Ok
try:
result = aostats.initialize()
return INITIALIZATION_RESULT[result]
except:
pass
def subscribe(callback):
if TEST_ENV_ENABLED:
return _testing_call_sequence(callback)
aostats.subscribe(callback)
def _testing_call_sequence(callback):
def add_player(id, name, weapon, event_name='PlayerAppeared'):
return [
{'name': event_name, 'value': {'id': id, 'name': name}},
{'name': 'UpdateItems', 'value': {'source': id, 'value': {
'weapon': weapon}}},
]
import threading
import time
sequence = [
{'name': 'ZoneChange'},
*add_player(0, 'Arcane', 'T4_MAIN_ARCANESTAFF@3', event_name='MainPlayerAppeared'),
*add_player(1, 'Cursed', 'T5_MAIN_CURSEDSTAFF@2'),
*add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'),
*add_player(3, 'Frost', 'T5_MAIN_FROSTSTAFF@1'),
*add_player(4, 'Holy', 'T6_MAIN_HOLYSTAFF'),
*add_player(5, 'Nature', 'T8_MAIN_NATURESTAFF@3'),
*add_player(6, 'Axe', 'T8_MAIN_AXE'),
*add_player(7, 'Dagger', 'T8_MAIN_DAGGER@2'),
*add_player(8, 'Hammer', 'T7_MAIN_HAMMER@2'),
*add_player(9, 'Mace', 'T6_MAIN_MACE@2'),
*add_player(10, 'Quarterstaff', 'T5_2H_IRONCLADEDSTAFF@2'),
*add_player(11, 'Spear', 'T8_MAIN_SPEAR@2'),
*add_player(12, 'Sword', 'T7_2H_CLAYMORE@2'),
*add_player(13, 'Bow', 'T8_2H_BOW@2'),
*add_player(14, 'Crossbow', 'T8_2H_CROSSBOWLARGE@3'),
{'name': 'EnterCombat', 'value': {'id': 0, 'name': 'Arcane'}},
{'sleep': 1},
{'name': 'DamageDone', 'value': {'source': 0, 'value': 100.0}},
{'sleep': 1.2},
{'name': 'LeaveCombat', 'value': {'id': 0, 'name': 'Arcane'}},
]
def run_sequence():
for v in sequence:
if 'sleep' in v:
time.sleep(v['sleep'])
else:
callback(v)
thread = threading.Thread(target=run_sequence, daemon=True)
thread.start()
+172
View File
@@ -0,0 +1,172 @@
from .utils.config import config
from .utils.number import Number
from .environment import TEST_ENV_ENABLED
from . import backend_proxy
from .backend_proxy import InitializationResult, INITIALIZATION_RESULT
from .stats import damage_stats
class StatType:
Unknown = 0
LastFight = 1
Zone = 2
Overall = 3
class GameStats:
def __init__(self):
self.zone = damage_stats.DamageStats()
self.last_fight = damage_stats.DamageStats()
self.overall = []
def register_event(self, event):
if event['name'] == 'MainPlayerAppeared':
self.zone.add_player(
event['value']['id'], event['value']['name'])
elif event['name'] == 'PlayerAppeared':
self.zone.add_player(
event['value']['id'], event['value']['name'])
elif event['name'] == 'DamageDone':
self.zone.register_damage_done(
event['value']['source'], event['value']['value'])
elif event['name'] == 'HealthReceived':
pass
elif event['name'] == 'ZoneChange':
self.zone = damage_stats.DamageStats()
elif event['name'] == 'EnterCombat':
self.zone.enter_combat(
event['value']['id'])
elif event['name'] == 'LeaveCombat':
self.zone.leave_conbat(
event['value']['id'])
if not any(player.combat_state == player.CombatState.InCombat for player in self.zone.players):
self.last_fight = damage_stats.DamageStats()
elif event['name'] == 'UpdateFame':
pass
elif event['name'] == 'UpdateItems':
self.zone.add_items(
event['value']['source'], event['value']['value'])
def reset(self, stat_type):
if stat_type == StatType.Zone:
self.zone = damage_stats.DamageStats()
self.last_fight = damage_stats.DamageStats()
elif stat_type == StatType.LastFight:
self.last_fight = damage_stats.DamageStats()
elif stat_type == StatType.Overall:
self.zone = damage_stats.DamageStats()
self.last_fight = []
def damage_stats(self, stat_type):
if stat_type == StatType.Zone:
return self.zone.stats()
elif stat_type == StatType.LastFight:
return self.last_fight.stats()
elif stat_type == StatType.Overall:
return damage_stats.combined_stats(self.overall + self.zone.stats())
game_stats = GameStats()
class DamageStat:
def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage):
self.name = name
self.items = items
self.damage = Number(damage)
self.time_in_combat = Number(time_in_combat)
self.dps = Number(dps)
self.percentage = Number(percentage)
self.best_damage = Number(best_damage)
def __str__(self):
return "Name {} Damage {} DPS {} percentage {} items {}".format(self.name, self.damage, self.dps, self.percentage, self.items)
def __eq__(self, other):
return self.name == other.name and self.damage == other.damage and self.time_in_combat == other.time_in_combat and self.dps == other.dps
class FameStat:
def __init__(self, fame, fame_per_hour):
self.fame = fame
self.fame_per_hour = fame_per_hour
def stats(session, with_dmg=False):
players = session['players']
main_player = session['main']
with_damage = [s for s in players if s['damage']
!= 0.0] if with_dmg else players
extended_session = with_percentage(with_damage)
statistics = [DamageStat(
s['player'],
s['items'],
s['damage'],
s['time_in_combat'],
s['dps'],
s['dmg_percentage'],
s['best_damage']) for s in extended_session]
elapsed = 0
fame = FameStat(Number(0.0), Number(0.0))
if main_player:
if 'fame' in main_player:
fame = FameStat(Number(main_player['fame']), Number(
main_player['fame_per_hour']))
if 'seconds_in_game' in main_player:
elapsed = main_player['seconds_in_game']
return statistics, fame, elapsed
def with_percentage(session):
best_damage = 0.0
damage_done = 0.0
for s in session:
damage = s['damage']
if damage > best_damage:
best_damage = damage
damage_done += damage
for s in session:
s['dmg_percentage'] = s['damage'] / \
damage_done * 100 if s['damage'] else 0.0
s['best_damage'] = best_damage
return session
def zone_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.Zone),
'main': {}},
with_damage)
def overall_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.Overall),
'main': {}},
with_damage)
def last_fight_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.LastFight),
'main': {}},
with_damage)
def reset_zone_stats():
game_stats.reset(StatType.Zone)
def reset_last_fight_stats():
game_stats.reset(StatType.LastFight)
def reset_stats():
game_stats.reset(StatType.Overall)
def initialize():
backend_proxy.initialize()
backend_proxy.subscribe(game_stats.register_event)
+18
View File
@@ -0,0 +1,18 @@
import os
TEST_ENV_ENABLED = bool(os.getenv('TESTING'))
class TestType:
Simple = 1
_test_types = {
'simple': TestType.Simple
}
if TEST_ENV_ENABLED:
test_type = os.getenv('TESTING')
if test_type not in _test_types:
raise Exception('Unavailable GUI test type, avaliable values: {}'.format(','.join(_test_types.keys())))
TEST_TYPE = _test_types[os.getenv('TESTING').lower()]
View File
@@ -1,16 +1,18 @@
from .version import latest_url from ..engine import InitializationResult
from .version import latest_version as get_latest_version from ..engine import initialize
from .version import current_version as get_current_version from ..utils.config import config
from .styling import style
from .engine import InitializationResult
from .engine import initialize
from .main import MainWidget from .main import MainWidget
from .config import config from .styling import style
from PySide2.QtWidgets import QMessageBox from ..utils.version import current_version as get_current_version
from PySide2.QtWidgets import QApplication from ..utils.version import latest_url
from ..utils.version import latest_version as get_latest_version
from PySide2.QtCore import Qt from PySide2.QtCore import Qt
import sys from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QMessageBox
import os import os
import sys
sys.path.append(os.path.dirname(os.path.abspath('__file__'))) sys.path.append(os.path.dirname(os.path.abspath('__file__')))
@@ -1,30 +1,28 @@
import collections from ..utils import assets
import functools from ..utils import names
from ..utils import async_request
from ..utils import weapon
from PIL import Image, ImageQt from PIL import Image, ImageQt
from io import BytesIO from PySide2 import QtCore
import re from PySide2 import QtGui
from PySide2.QtCore import Qt from PySide2.QtCore import Qt
from PySide2.QtGui import QStandardItem
from PySide2.QtGui import QStandardItemModel
from PySide2.QtWidgets import QApplication from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QMessageBox from PySide2.QtWidgets import QComboBox
from PySide2.QtWidgets import QHBoxLayout from PySide2.QtWidgets import QHBoxLayout
from PySide2.QtWidgets import QLabel
from PySide2.QtWidgets import QListView
from PySide2.QtWidgets import QMessageBox
from PySide2.QtWidgets import QProgressBar
from PySide2.QtWidgets import QPushButton from PySide2.QtWidgets import QPushButton
from PySide2.QtWidgets import QVBoxLayout from PySide2.QtWidgets import QVBoxLayout
from PySide2.QtWidgets import QLabel
from PySide2.QtWidgets import QComboBox
from PySide2.QtWidgets import QProgressBar
from PySide2.QtWidgets import QListView
from PySide2.QtGui import QStandardItemModel
from PySide2.QtGui import QStandardItem
from PySide2 import QtGui from io import BytesIO
from PySide2 import QtCore import collections
import functools
from . import weapon import re
from . import names
from . import assets
from . import async_request
Style = collections.namedtuple('Style', 'bg') Style = collections.namedtuple('Style', 'bg')
@@ -17,9 +17,9 @@ from PySide2 import QtCore
from .dmg_list import DmgList from .dmg_list import DmgList
from . import about from . import about
from . import engine from .. import engine
from . import assets from ..utils import assets
from .config import config from ..utils.config import config
class Mode: class Mode:
@@ -1,4 +1,4 @@
from .config import config from ..utils.config import config
cfg = config() cfg = config()
font_size = cfg['window']['font-size'] font_size = cfg['window']['font-size']
View File
+125
View File
@@ -0,0 +1,125 @@
# Example output
# 'player': 'Cursed',
# 'damage': 1100.0,
# 'time_in_combat': 12.0,
# 'dps': 222,
# 'items': {
# 'weapon': 'T5_MAIN_CURSEDSTAFF@2'
# }
from datetime import datetime
class Player:
class CombatTime:
def __init__(self):
self.entered_combat = None
self.time_in_combat = 0.0
class CombatState:
InCombat = 1
OutOfCombat = 2
def __init__(self, name):
self.name = name
self.damage_done = 0.0
self.items = {'weapon': None}
self.combat_time = self.CombatTime()
self.combat_state = self.CombatState.OutOfCombat
@staticmethod
def from_other(other):
Player(other.name)
def register_items(self, value):
self.items = value
def register_damage_done(self, value):
if self.combat_state == self.CombatState.OutOfCombat:
return
self.damage_done += value
def enter_combat(self):
self.combat_time.entered_combat = datetime.now()
self.combat_state = self.CombatState.InCombat
def leave_combat(self):
if self.combat_time.entered_combat:
self.combat_time.time_in_combat += _time_delta(self.combat_time.entered_combat)
self.combat_state = self.CombatState.OutOfCombat
@property
def time_in_combat(self):
if self.combat_state == self.CombatState.InCombat:
if self.combat_time.entered_combat:
return self.combat_time.time_in_combat + _time_delta(self.combat_time.entered_combat)
return self.combat_time.time_in_combat
@property
def dps(self):
if self.time_in_combat == 0.0:
return 0.0
return (self.damage_done / self.time_in_combat) * 1000.0
def stats(self):
return {
'player': self.name,
'damage': self.damage_done,
'time_in_combat': self.time_in_combat,
'dps': self.dps,
'items': self.items}
class DamageStats:
def __init__(self, players=None):
if not players:
players = {}
self.players = players
@staticmethod
def from_other(other):
DamageStats({k: Player.from_other(v)} for k, v in other.players)
def add_player(self, player_id, name):
if player_id not in self.players:
self.players[player_id] = Player(name)
def add_items(self, player_id, items):
self.players[player_id].register_items(items)
def enter_combat(self, player_id):
self.players[player_id].enter_combat()
def leave_conbat(self, player_id):
self.players[player_id].leave_combat()
def register_damage_done(self, player_id, value):
self.players[player_id].register_damage_done(value)
def stats(self):
return [player.stats() for player in self.players.values()]
def combined_stats(stats_list):
combined = {}
for stats in stats_list:
if stats['player'] in combined:
current = combined[stats['player']]
current['damage'] += stats['damage']
current['time_in_combat'] += stats['time_in_combat']
current['dps'] += stats['dps']
current['items'] = stats['items']
else:
combined[stats['player']] = stats
return [s for s in combined.values()]
def _time_delta(time):
delta = datetime.now() - time
return (delta.seconds * 1000.0 + delta.microseconds / 1000.0)
+2
View File
@@ -0,0 +1,2 @@
from . import number
from . import config
@@ -1,6 +1,6 @@
import os import os
assets_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'assets') assets_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'assets')
def path(file): def path(file):
return os.path.join(assets_path, file) return os.path.join(assets_path, file)
@@ -1,6 +1,6 @@
import pytest import pytest
from number import Number from src.number import Number
def test_number_equality(): def test_number_equality():
n = 10 n = 10
+24
View File
@@ -0,0 +1,24 @@
[tox]
skipsdist=True
envlist = python3
[testenv]
deps =
pytest
pyside2~=5.13
pyinstaller
toml~=0.10
requests~=2.22
Pillow~=6.2
[testenv:flake8]
deps =
flake8==3.7.9
flake8-import-order==0.18.1
commands =
flake8 src
[testenv:ut]
commands =
python -m pytest tests
+6 -2
View File
@@ -30,11 +30,15 @@ test_script:
- ps: cd backend - ps: cd backend
- cargo test - cargo test
- ps: cd .. - ps: cd ..
- pip install tox
- ps: cd frontend
- tox -e ut
- pd: cd ..
build_script: build_script:
- python -m venv env - python -m venv env
- ps: .\env\Scripts\activate.ps1 - ps: .\env\Scripts\activate.ps1
- pip install -v -r frontend\requirements.txt - pip install -v -r application\requirements.txt
- pyinstaller -F -w -i assets\albion-stats-icon.ico --add-data frontend\src\assets;src\assets frontend\albion-online-stats.py - pyinstaller -F -w -i assets\albion-stats-icon.ico --add-data application\src\assets;src\assets application\albion-online-stats.py
- ps: deactivate - ps: deactivate
after_build: after_build:
- ps: mv dist\albion-online-stats.exe albion-online-stats.exe - ps: mv dist\albion-online-stats.exe albion-online-stats.exe
+22 -2
View File
@@ -39,6 +39,15 @@ version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7" checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
[[package]]
name = "bimap"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "783204f24fd7724ea274d327619cfa6a6018047bb0561a68aadff6f56787591b"
dependencies = [
"cfg-if",
]
[[package]] [[package]]
name = "bitflags" name = "bitflags"
version = "0.5.0" version = "0.5.0"
@@ -127,6 +136,17 @@ dependencies = [
"lazy_static", "lazy_static",
] ]
[[package]]
name = "derive_more"
version = "0.99.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2159be042979966de68315bce7034bb000c775f22e3e834e1c52ff78f041cae8"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "dirs" name = "dirs"
version = "1.0.5" version = "1.0.5"
@@ -205,9 +225,11 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
name = "libaostats" name = "libaostats"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"bimap",
"bytes", "bytes",
"chrono 0.4.10", "chrono 0.4.10",
"cpython", "cpython",
"derive_more",
"fake_clock", "fake_clock",
"lazy_static", "lazy_static",
"log 0.4.8", "log 0.4.8",
@@ -301,8 +323,6 @@ dependencies = [
[[package]] [[package]]
name = "photon_decode" name = "photon_decode"
version = "0.2.1" version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2aecada6e930f101768a1f1659b1f9c9872cea3d479dfeae3031927f67093f1"
dependencies = [ dependencies = [
"bytes", "bytes",
] ]
+4 -1
View File
@@ -8,6 +8,7 @@ build = "build.rs"
[lib] [lib]
name = "libaostats" name = "libaostats"
path = "src/lib_python.rs"
crate-type = ["dylib"] crate-type = ["dylib"]
[dependencies.cpython] [dependencies.cpython]
@@ -15,13 +16,15 @@ version = "0.3"
[dependencies] [dependencies]
packet_sniffer = { path = "./lib/packet-sniffer" } packet_sniffer = { path = "./lib/packet-sniffer" }
photon_decode = "0.2" photon_decode = { path = "./lib/photon-decode" }
bytes = "0.4" bytes = "0.4"
simplelog = "0.6" simplelog = "0.6"
timer = "0.1" timer = "0.1"
chrono = "0.4" chrono = "0.4"
log = { version = "0.4", features = ["std"] } log = { version = "0.4", features = ["std"] }
lazy_static = "1.2" lazy_static = "1.2"
derive_more = "0.99"
bimap = "0.4.0"
[build-dependencies] [build-dependencies]
serde_json = "1.0" serde_json = "1.0"
+4 -4
View File
@@ -69,7 +69,7 @@ fn generate_messages() -> String {
let mut out = String::new(); let mut out = String::new();
out.push_str(r"use log::*; out.push_str(r"use log::*;
use crate::game_messages::Items; use crate::photon_messages::Items;
use photon_decode::Parameters; use photon_decode::Parameters;
use photon_decode::Value; use photon_decode::Value;
@@ -89,7 +89,7 @@ use photon_decode::Value;
} }
out.push_str(&format!(r###" out.push_str(&format!(r###"
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct {} {{ pub struct {} {{
{} {}
}} }}
@@ -128,7 +128,7 @@ impl {0} {{
"###, msg.name, parse_body, param_names)); "###, msg.name, parse_body, param_names));
} }
out.push_str("\n#[derive(Debug)]\n"); out.push_str("\n#[derive(Debug, Clone, PartialEq)]\n");
out.push_str("pub enum Message {\n"); out.push_str("pub enum Message {\n");
for msg in &[&messages.events[..], &messages.responses[..]].concat() { for msg in &[&messages.events[..], &messages.responses[..]].concat() {
out.push_str(&format!(" {0}({0}),\n", msg.name)); out.push_str(&format!(" {0}({0}),\n", msg.name));
@@ -208,7 +208,7 @@ fn generate_itemdb() -> String {
} }
fn save_file(file_name: &str, content: &str) { fn save_file(file_name: &str, content: &str) {
let dest_path = Path::new(&"src/game_messages").join(file_name); let dest_path = Path::new(&"src/photon_messages").join(file_name);
let mut f = File::create(&dest_path).unwrap(); let mut f = File::create(&dest_path).unwrap();
f.write_all(content.as_bytes()).unwrap(); f.write_all(content.as_bytes()).unwrap();
} }
+4
View File
@@ -0,0 +1,4 @@
&.rs.bk
/target
*.so
.vscode
+48
View File
@@ -0,0 +1,48 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "byteorder"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bytes"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "iovec"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "libc"
version = "0.2.60"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "photon_decode"
version = "0.2.1"
dependencies = [
"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[metadata]
"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
"checksum libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)" = "d44e80633f007889c7eff624b709ab43c92d708caad982295768a7b13ca3b5eb"
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+15
View File
@@ -0,0 +1,15 @@
[package]
name = "photon_decode"
version = "0.2.1"
authors = ["Wiktor Mazur <wiktormazur1@gmail.com>"]
edition = "2018"
description = "Set of utilities for decoding messages generated by photon framework."
repository = "https://github.com/mazurwiktor/photon_decode"
license = "MIT/Apache-2.0"
readme = "README.md"
documentation = "https://docs.rs/photon_decode/*/photon_decode/"
categories = ["network-programming", "encoding"]
keywords = ["games", "multiplayer", "photon", "unity", "unrealengine"]
[dependencies]
bytes = "0.4"
+59
View File
@@ -0,0 +1,59 @@
Photon decode
=============
Set of utilities for decoding messages generated by *photon framework.
*Photon is a development framework for multiplayer games. More on https://www.photonengine.com/.
[![Documentation](https://docs.rs/photon_decode/badge.svg)](https://docs.rs/photon_decode/*/photon_decode/)
## Usage
To use `photon_decode`, first add this to your `Cargo.toml`:
```toml
[dependencies]
photon_decode = "0.1"
```
```rust
use photon_decode::{Photon, Message};
let mut photon = Photon::new();
let photon_packet = vec![
0x00, 0x01, // PeerID
0x01, // CrcEnabled
0x00, // CommandCount
0x00, 0x00, 0x00, 0x01, // Timestamp
0x00, 0x00, 0x00, 0x01, // Challenge
];
for message in photon.decode(&photon_packet).iter() {
match message {
Message::Event(_) => {
// use event
},
Message::Request(_) => {
// use request
},
Message::Response(_) => {
// use response
}
}
}
```
# Projects using photon decode
https://github.com/mazurwiktor/albion-online-stats - Albion online stats is an extension to MMORPG game - Albion Online. It tracks network traffic and displays various statistics, such as damage and DPS meter calculated from in-game actions.
# License
Licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.
+472
View File
@@ -0,0 +1,472 @@
use std::collections::HashMap;
use std::io::{Cursor, Read};
use std::mem::size_of;
use bytes::Buf;
use crate::error::*;
use crate::layout::*;
pub type PhotonCursor<'a> = Cursor<&'a [u8]>;
pub trait Decode<T> {
fn decode(&mut self) -> PhotonDecodeResult<T>;
}
trait TypedDecode {
fn typed_decode(&mut self, type_code: u8) -> PhotonDecodeResult<Value>;
}
macro_rules! impl_decode {
($type:ty, $decode_func:ident, $bytes_to_consume:expr) => {
impl Decode<$type> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<$type> {
let v = if self.remaining() >= $bytes_to_consume {
self.$decode_func()
} else {
return Err(PhotonDecodeError::from(concat!(
"Failed to decode ",
stringify!($type),
", not enough bytes"
)));
};
Ok(v)
}
}
};
}
impl_decode!(u8, get_u8, 1);
impl_decode!(f32, get_f32_be, 4);
impl_decode!(u32, get_u32_be, 4);
impl_decode!(i64, get_i64_be, 8);
impl_decode!(i16, get_i16_be, 2);
impl_decode!(f64, get_f64_be, 8);
impl Decode<bool> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<bool> {
let v = if self.remaining() >= 1 {
self.get_u8()
} else {
return Err(PhotonDecodeError::from(
"Failed to decode bool, not enough bytes",
));
};
Ok(v != 0)
}
}
impl Decode<String> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<String> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode String, unreasonable size",
));
}
let mut local_buffer = vec![0; size as usize];
if let Ok(_) = self.read_exact(&mut local_buffer[..]) {
if let Ok(s) = String::from_utf8(local_buffer) {
return Ok(s);
}
}
Err(PhotonDecodeError::from(
"Failed to decode String, not enough bytes",
))
}
}
impl Decode<Vec<String>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Vec<String>> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode String, unreasonable size",
));
}
let mut value: Vec<String> = vec![];
for _ in 0..size {
value.push(self.decode()?);
}
Ok(value)
}
}
impl Decode<Vec<u8>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Vec<u8>> {
let size: u32 = self.decode()?;
let mut value: Vec<u8> = vec![];
for _ in 0..size {
value.push(self.decode()?);
}
Ok(value)
}
}
impl Decode<Vec<Value>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Vec<Value>> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode Vec<Value>, unreasonable size",
));
}
let type_code: u8 = self.decode()?;
let mut value: Vec<Value> = vec![];
for _ in 0..size {
if let Ok(v) = self.typed_decode(type_code) {
value.push(v);
} else {
break;
}
}
Ok(value)
}
}
impl Decode<HashMap<String, Value>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<HashMap<String, Value>> {
let key_type_code: u8 = self.decode()?;
let value_type_code: u8 = self.decode()?;
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode HashMap<String, Value>, unreasonable size",
));
}
let mut value: HashMap<String, Value> = HashMap::new();
for _ in 0..size {
let key_code: u8 = if key_type_code == 0 || key_type_code == 42 {
self.decode()?
} else {
key_type_code
};
let key = self.typed_decode(key_code);
let value_code: u8 = if value_type_code == 0 || value_type_code == 42 {
self.decode()?
} else {
value_type_code
};
let val = self.typed_decode(value_code);
if let (Ok(key), Ok(val)) = (key, val) {
value.insert(format!("{}", key), val);
}
}
Ok(value)
}
}
impl Decode<HashMap<u8, Value>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<HashMap<u8, Value>> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode HashMap<u8, Value>, unreasonable size",
));
}
let mut value: HashMap<u8, Value> = HashMap::new();
for _ in 0..size {
let key_type_code: u8 = if let Ok(v) = self.decode() {
v
} else {
break;
};
let val: Value = if let Ok(v) = self.decode() {
v
} else {
break;
};
value.insert(key_type_code, val);
}
Ok(value)
}
}
impl Decode<EventData> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<EventData> {
let code: u8 = self.decode()?;
let parameters: HashMap<u8, Value> = self.decode()?;
Ok(EventData { code, parameters })
}
}
impl Decode<OperationResponse> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<OperationResponse> {
let code: u8 = self.decode()?;
let return_code: i16 = self.decode()?;
let maybe_debug_message: Value = self.decode()?;
let debug_message = if let Value::String(s) = maybe_debug_message {
s
} else {
"None".to_owned()
};
let parameters: HashMap<u8, Value> = self.decode()?;
Ok(OperationResponse {
code,
return_code,
debug_message,
parameters,
})
}
}
impl Decode<OperationRequest> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<OperationRequest> {
let code: u8 = self.decode()?;
let parameters: HashMap<u8, Value> = self.decode()?;
Ok(OperationRequest { code, parameters })
}
}
impl Decode<Vec<Box<Value>>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Vec<Box<Value>>> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode Vec<Box<Value>>, unreasonable size",
));
}
let mut value = vec![];
for _ in 0..size {
let type_code: u8 = if let Ok(v) = self.decode() {
v
} else {
break;
};
if let Ok(val) = self.typed_decode(type_code) {
value.push(Box::new(val));
}
}
Ok(value)
}
}
impl Decode<Vec<bool>> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Vec<bool>> {
let size: i16 = self.decode()?;
if size < 0 {
return Err(PhotonDecodeError::from(
"Failed to decode Vec<bool>, unreasonable size",
));
}
let mut value = vec![];
for _ in 0..size {
value.push(self.decode()?);
}
Ok(value)
}
}
impl TypedDecode for PhotonCursor<'_> {
fn typed_decode(&mut self, type_code: u8) -> PhotonDecodeResult<Value> {
match TypeCode::from(type_code) {
TypeCode::None => Ok(Value::None),
TypeCode::Null => Ok(Value::None),
TypeCode::Boolean => Ok(Value::Boolean(self.decode()?)),
TypeCode::Byte => Ok(Value::Byte(self.decode()?)),
TypeCode::Double => Ok(Value::Double(self.decode()?)),
TypeCode::Float => Ok(Value::Float(self.decode()?)),
TypeCode::Integer => Ok(Value::Integer(self.decode()?)),
TypeCode::Long => Ok(Value::Long(self.decode()?)),
TypeCode::Short => Ok(Value::Short(self.decode()?)),
TypeCode::String => Ok(Value::String(self.decode()?)),
TypeCode::StringArray => Ok(Value::StringArray(self.decode()?)),
TypeCode::ByteArray => Ok(Value::ByteArray(self.decode()?)),
TypeCode::Dictionary => Ok(Value::Dictionary(self.decode()?)),
TypeCode::EventData => Ok(Value::EventData(self.decode()?)),
TypeCode::OperationRequest => Ok(Value::OperationRequest(self.decode()?)),
TypeCode::OperationResponse => Ok(Value::OperationResponse(self.decode()?)),
TypeCode::BooleanArray => Ok(Value::BooleanArray(self.decode()?)),
TypeCode::Array => Ok(Value::Array(self.decode()?)),
TypeCode::ObjectArray => Ok(Value::ObjectArray(self.decode()?)),
_ => Err(PhotonDecodeError::from(format!(
"Failed to decode Value, unknown type code ({:#X})",
type_code
))),
}
}
}
impl Decode<Value> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Value> {
let type_code: u8 = self.decode()?;
self.typed_decode(type_code)
}
}
impl Decode<PhotonHeader> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<PhotonHeader> {
let peer_id = self.decode()?;
let crc_enabled = self.decode()?;
let command_count = self.decode()?;
let timestamp = self.decode()?;
let challenge = self.decode()?;
Ok(PhotonHeader {
peer_id,
crc_enabled,
command_count,
timestamp,
challenge,
})
}
}
impl Decode<ReliableCommand> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<ReliableCommand> {
let channel_id = self.decode()?;
let flags = self.decode()?;
let reserved_byte = self.decode()?;
let length: u32 = self.decode()?;
let reliable_sequence_number = self.decode()?;
let msg_len = length.checked_sub(size_of::<ReliableCommand>() as u32)
.map_or(Err(PhotonDecodeError::from("Invalid ReliableCommand length")), |v| Ok(v))?;
Ok(ReliableCommand {
channel_id,
flags,
reserved_byte,
msg_len,
reliable_sequence_number,
})
}
}
impl Decode<UnreliableCommand> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<UnreliableCommand> {
let mut reliable_command: ReliableCommand = self.decode()?;
let unknown = self.decode()?;
reliable_command.msg_len = reliable_command.msg_len.checked_sub(size_of::<u32>() as u32)
.map_or(Err(PhotonDecodeError::from("Invalid UnreliableCommand length")), |v| Ok(v))?;
Ok(UnreliableCommand {
reliable_command,
unknown,
})
}
}
impl Decode<ReliableFragment> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<ReliableFragment> {
let mut reliable_command: ReliableCommand = self.decode()?;
let sequence_number = self.decode()?;
let fragment_count = self.decode()?;
let fragment_number = self.decode()?;
let total_length = self.decode()?;
let operation_length = self.decode()?;
reliable_command.msg_len = reliable_command.msg_len.checked_sub((size_of::<u32>() * 5) as u32)
.map_or(Err(PhotonDecodeError::from("Invalid ReliableFragment length")), |v| Ok(v))?;
let mut payload = vec![0u8; reliable_command.msg_len as usize];
self.read_exact(&mut payload)
.map_err(|e| PhotonDecodeError::from(format!("{}", e)))?;
Ok(ReliableFragment {
reliable_command,
sequence_number,
fragment_count,
fragment_number,
total_length,
operation_length,
payload,
})
}
}
impl Decode<Command> for PhotonCursor<'_> {
fn decode(&mut self) -> PhotonDecodeResult<Command> {
let cmd_type_id: u8 = self.decode()?;
match cmd_type_id {
4 => Ok(Command::LogOut),
6 => Ok(Command::SendReliable(self.decode()?)),
7 => Ok(Command::SendUnreliable(
Decode::<UnreliableCommand>::decode(self)?.reliable_command,
)),
8 => Ok(Command::SendReliableFragment(self.decode()?)),
_ => Ok(Command::SendReliable(self.decode()?)),
}
}
}
pub enum TypeCode {
None = 0x00,
Null = 0x2A,
Dictionary = 0x44,
StringArray = 0x61,
Byte = 0x62,
Double = 0x64,
EventData = 0x65,
Float = 0x66,
Integer = 0x69,
Short = 0x6B,
Long = 0x6C,
BooleanArray = 0x6E,
Boolean = 0x6F,
OperationResponse = 0x70,
OperationRequest = 0x71,
String = 0x73,
ByteArray = 0x78,
Array = 0x79,
ObjectArray = 0x7A,
Unknown,
}
impl From<u8> for TypeCode {
fn from(v: u8) -> Self {
match v {
0x00 => TypeCode::None,
0x2A => TypeCode::Null,
0x44 => TypeCode::Dictionary,
0x61 => TypeCode::StringArray,
0x62 => TypeCode::Byte,
0x64 => TypeCode::Double,
0x65 => TypeCode::EventData,
0x66 => TypeCode::Float,
0x69 => TypeCode::Integer,
0x6B => TypeCode::Short,
0x6C => TypeCode::Long,
0x6E => TypeCode::BooleanArray,
0x6F => TypeCode::Boolean,
0x70 => TypeCode::OperationResponse,
0x71 => TypeCode::OperationRequest,
0x73 => TypeCode::String,
0x78 => TypeCode::ByteArray,
0x79 => TypeCode::Array,
0x7A => TypeCode::ObjectArray,
_ => TypeCode::Unknown,
}
}
}
impl std::ops::Index<usize> for Value {
type Output = Value;
fn index(&self, index: usize) -> &Self::Output {
match self {
Value::Array(v) => &v[index],
_ => panic!("Non indexable type"),
}
}
}
impl std::fmt::Display for Value {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Value::String(v) => write!(f, "{}", v),
Value::Byte(v) => write!(f, "{}", v),
Value::Integer(v) => write!(f, "{}", v),
v => write!(f, "{:?}", v),
}
}
}
+36
View File
@@ -0,0 +1,36 @@
use core::fmt::{self, Display};
#[derive(Debug)]
pub struct PhotonDecodeError {
cause: String,
}
impl PhotonDecodeError {
pub fn extend(self, cause: String) -> Self {
Self {
cause: format!("{} {}", cause, self.cause),
}
}
}
pub type PhotonDecodeResult<T> = std::result::Result<T, PhotonDecodeError>;
impl Display for PhotonDecodeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Display::fmt(&self.cause, f)
}
}
// Allows writing `PhotonDecodeError::from("oops"))?`
impl From<&'static str> for PhotonDecodeError {
fn from(msg: &'static str) -> PhotonDecodeError {
PhotonDecodeError { cause: msg.into() }
}
}
// Allows writing `PhotonDecodeError::from("oops".into()))?`
impl From<String> for PhotonDecodeError {
fn from(msg: String) -> PhotonDecodeError {
PhotonDecodeError { cause: msg }
}
}
+94
View File
@@ -0,0 +1,94 @@
use std::collections::HashMap;
#[derive(Clone, Debug, PartialEq)]
pub enum Value {
None,
Dictionary(HashMap<String, Value>),
StringArray(Vec<String>),
Byte(u8),
Double(f64),
EventData(EventData),
Float(f32),
Integer(u32),
Short(i16),
Long(i64),
BooleanArray(Vec<bool>),
Boolean(bool),
OperationResponse(OperationResponse),
OperationRequest(OperationRequest),
String(String),
ByteArray(Vec<u8>),
Array(Vec<Value>),
Object(Box<Value>),
ObjectArray(Vec<Box<Value>>),
}
pub type Parameters = HashMap<u8, Value>;
#[derive(Clone, Debug, PartialEq)]
pub struct EventData {
pub code: u8,
pub parameters: Parameters,
}
#[derive(Clone, Debug, PartialEq)]
pub struct OperationResponse {
pub code: u8,
pub return_code: i16,
pub debug_message: String,
pub parameters: Parameters,
}
#[derive(Clone, Debug, PartialEq)]
pub struct OperationRequest {
pub code: u8,
pub parameters: Parameters,
}
#[derive(Debug, PartialEq)]
pub enum Message {
Request(OperationRequest),
Response(OperationResponse),
Event(EventData),
}
#[derive(Debug)]
pub struct PhotonHeader {
pub peer_id: i16,
pub crc_enabled: bool,
pub command_count: u8,
pub timestamp: u32,
pub challenge: u32,
}
#[derive(Debug, Clone)]
pub struct ReliableCommand {
pub channel_id: u8,
pub flags: u8,
pub reserved_byte: u8,
pub msg_len: u32,
pub reliable_sequence_number: u32,
}
pub struct UnreliableCommand {
pub reliable_command: ReliableCommand,
pub unknown: u32,
}
#[derive(Debug, Clone)]
pub struct ReliableFragment {
pub reliable_command: ReliableCommand,
pub sequence_number: u32,
pub fragment_count: u32,
pub fragment_number: u32,
pub total_length: u32,
pub operation_length: u32,
pub payload: Vec<u8>,
}
pub enum Command {
LogOut,
SendUnreliable(ReliableCommand),
SendReliable(ReliableCommand),
SendReliableFragment(ReliableFragment),
}
+114
View File
@@ -0,0 +1,114 @@
mod decode;
mod error;
mod layout;
pub use decode::*;
use error::*;
pub use layout::*;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::io::Cursor;
impl TryFrom<(&ReliableCommand, &mut Cursor<&[u8]>)> for Message {
type Error = PhotonDecodeError;
fn try_from(message: (&ReliableCommand, &mut Cursor<&[u8]>)) -> Result<Self, Self::Error> {
let (command, cursor) = message;
let _: u8 = cursor.decode()?;
let msg_type: u8 = cursor.decode()?;
match msg_type {
2 => {
let v = cursor.decode().map_err(|e| e.extend("Request".into()))?;
Ok(Message::Request(v))
}
3 => {
let v = cursor.decode().map_err(|e| e.extend("Response".into()))?;
Ok(Message::Response(v))
}
4 => {
let v = cursor.decode().map_err(|e| e.extend("Event".into()))?;
Ok(Message::Event(v))
}
_ => {
let msg_header_len = 2;
cursor.set_position(cursor.position() + command.msg_len as u64 - msg_header_len);
Err(PhotonDecodeError::from(format!(
"Unknown message ({:#X})",
msg_type
)))
}
}
}
}
pub struct Photon {
fragments: HashMap<u32, Vec<ReliableFragment>>,
}
impl Photon {
pub fn new() -> Self {
Self {
fragments: HashMap::new(),
}
}
pub fn try_decode(
&mut self,
payload: &[u8],
) -> PhotonDecodeResult<Vec<PhotonDecodeResult<Message>>> {
let mut cursor = Cursor::new(payload);
Ok(
(0..Decode::<PhotonHeader>::decode(&mut cursor)?.command_count)
.into_iter()
.map(|_| {
Decode::<Command>::decode(&mut cursor).map_or_else(
|e| Some(Err(e)),
|command| match command {
Command::SendReliable(c) | Command::SendUnreliable(c) => Some(
Message::try_from((&c, &mut cursor))
.map_err(|e| e.extend("SendReliable".into())),
),
Command::SendReliableFragment(fragment) => {
self.fragments
.entry(fragment.sequence_number)
.or_insert(vec![])
.push(fragment.clone());
self.decode_reliable_fragment(&fragment).map(|msg| {
self.fragments.remove(&fragment.sequence_number).unwrap();
msg.map_err(|e| e.extend("Fragment".into()))
})
}
_ => None,
},
)
})
.filter_map(|v| v)
.collect(),
)
}
pub fn decode(&mut self, payload: &[u8]) -> Vec<Message> {
if let Ok(messages) = self.try_decode(payload) {
return messages.into_iter().filter_map(Result::ok).collect();
}
vec![]
}
fn decode_reliable_fragment(
&mut self,
fragment: &ReliableFragment,
) -> Option<PhotonDecodeResult<Message>> {
if let Some(fragments) = self.fragments.get(&fragment.sequence_number) {
if fragments.len() == fragment.fragment_count as usize {
let mut buf = Vec::<u8>::new();
for fragment in fragments {
buf.extend(fragment.payload.iter());
}
let mut c = Cursor::new(&buf[..]);
return Some(Message::try_from((&fragment.reliable_command, &mut c)));
}
}
None
}
}
@@ -0,0 +1,361 @@
use photon_decode::*;
use std::io::Cursor;
#[test]
fn deserialize_dictionary() {
let value = vec![
68, 115, 115, 0, 2, 0, 8, 116, 101, 115, 116, 75, 101, 121, 49, 0, 10, 116, 101, 115,
116, 86, 97, 108, 117, 101, 49, 0, 8, 116, 101, 115, 116, 75, 101, 121, 50, 0, 10, 116,
101, 115, 116, 86, 97, 108, 117, 101, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Dictionary(v) => {
return assert_eq!(
v.get("testKey1"),
Some(&Value::String("testValue1".to_owned()))
)
}
_ => assert!(false),
}
}
#[test]
fn deserialize_string_array() {
let value = vec![
121, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Array(v) => {
if let Value::String(val) = &v[0] {
assert_eq!(val, &"test1".to_owned());
}
if let Value::String(val) = &v[1] {
assert_eq!(val, &"test2".to_owned());
}
return;
}
Value::StringArray(v) => {
return assert_eq!(vec!["test1".to_owned(), "test2".to_owned()], v)
}
_ => assert!(false),
}
}
#[test]
fn test_deserialize_byte() {
let value = vec![98, 6];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Byte(v) => return assert_eq!(v, 6),
_ => assert!(false),
}
}
#[test]
fn deserialize_double() {
let value = vec![100, 64, 147, 74, 51, 51, 51, 51, 51, 0, 0, 0, 0, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Double(v) => return assert_eq!(v, 1234.55),
_ => assert!(false),
}
}
#[test]
fn deserialize_event_data() {
let value = vec![
101, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116,
50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::EventData(v) => {
assert_eq!(v.code, 100);
assert_eq!(
v.parameters.get(&0).unwrap(),
&Value::String("test1".to_owned())
);
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_float() {
let value = vec![102, 68, 154, 81, 154, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Float(v) => return assert_eq!(v, 1234.55),
_ => assert!(false),
}
}
#[test]
fn deserialize_integer() {
let value = vec![105, 0, 0, 4, 210, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Integer(v) => return assert_eq!(v, 1234),
_ => assert!(false),
}
}
#[test]
fn deserialize_short() {
let value = vec![107, 4, 210, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Short(v) => return assert_eq!(v, 1234),
_ => assert!(false),
}
}
#[test]
fn deserialize_long() {
let value = vec![108, 0, 0, 0, 0, 0, 0, 4, 210, 0, 0, 0, 0, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Long(v) => return assert_eq!(v, 1234),
_ => assert!(false),
}
}
#[test]
fn deserialize_integer_array() {
let value = vec![121, 0, 2, 105, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Array(v) => {
if let Value::Integer(val) = v[0] {
assert_eq!(val, 0);
}
if let Value::Integer(val) = v[1] {
assert_eq!(val, 1);
}
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_boolean() {
let value = vec![111, 1];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Boolean(v) => return assert_eq!(v, true),
_ => assert!(false),
}
}
#[test]
fn deserialize_operation_response() {
let value = vec![
112, 100, 0, 100, 42, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116,
101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::OperationResponse(v) => {
assert_eq!(v.code, 100);
assert_eq!(v.return_code, 100);
assert_eq!(
v.parameters.get(&1).unwrap(),
&Value::String("test2".to_owned())
);
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_operation_request() {
let value = vec![
113, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116,
50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::OperationRequest(v) => {
assert_eq!(v.code, 100);
assert_eq!(
v.parameters.get(&1).unwrap(),
&Value::String("test2".to_owned())
);
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_string() {
let value = vec![
115, 0, 12, 116, 101, 115, 116, 95, 109, 101, 115, 115, 97, 103, 101, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::String(v) => return assert_eq!(&v, "test_message"),
_ => assert!(false),
}
}
#[test]
fn deserialize_byte_array() {
let value = vec![120, 0, 0, 0, 2, 6, 7, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::ByteArray(v) => {
assert_eq!(&v[0], &6);
assert_eq!(&v[1], &7);
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_array_dictionary() {
let value = vec![
121, 0, 1, 68, 105, 115, 0, 1, 0, 0, 0, 0, 0, 5, 116, 101, 115, 116, 49, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Array(v) => {
if let Value::Dictionary(val) = &v[0] {
assert_eq!(val.get("0").unwrap(), &Value::String("test1".to_owned()));
}
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_array_byte_array() {
let value = vec![121, 0, 1, 120, 0, 0, 0, 4, 0, 2, 4, 8, 0, 0, 0, 0];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Array(v) => {
if let Value::ByteArray(val) = &v[0] {
assert_eq!(val[0], 0);
assert_eq!(val[1], 2);
assert_eq!(val[2], 4);
assert_eq!(val[3], 8);
return;
}
}
_ => assert!(false),
}
}
#[test]
fn deserialize_array_array() {
let value = vec![
121, 0, 1, 121, 0, 3, 105, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::Array(v) => {
if let Value::Integer(val) = &v[0][0] {
assert_eq!(val, &1);
}
if let Value::Integer(val) = &v[0][1] {
assert_eq!(val, &2);
}
if let Value::Integer(val) = &v[0][2] {
assert_eq!(val, &3);
}
return;
}
_ => assert!(false),
}
}
#[test]
fn deserialize_object_array() {
let value = vec![
122, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
let mut buf = Cursor::new(&value[..]);
let result = buf.decode();
assert!(result.is_ok(), "Unimplemented!");
let value = result.unwrap();
match value {
Value::ObjectArray(v) => {
if let Value::Object(val) = &*v[0] {
assert_eq!(**val, Value::String("test1".to_owned()));
}
if let Value::Object(val) = &*v[1] {
assert_eq!(**val, Value::String("test2".to_owned()));
}
}
_ => assert!(false),
};
}
@@ -0,0 +1,311 @@
use photon_decode;
use photon_decode::Message;
use photon_decode::EventData;
use photon_decode::OperationRequest;
use photon_decode::OperationResponse;
use photon_decode::Value;
use photon_decode::Parameters;
#[test]
fn test_single_event_message()
{
let header = vec![
0x00, 0x01, // PeerID
0x01, // CrcEnabled
0x01, // CommandCount
0x00, 0x00, 0x00, 0x01, // Timestamp
0x00, 0x00, 0x00, 0x01, // Challenge
];
let photon_command = vec![
0x06, // Type
0x01, // ChannelID
0x01, // Flags
0x04, // ReservedByte
0x00, 0x00, 0x00, 0x1a, // Length
0x00, 0x00, 0x00, 0x01, // ReliableSequenceNumber
];
let message = vec![
0x01, // ??
0x04, // MsgType (Event)
// Payload
0x64, 0x00, 0x02, // Key
0x00, 0x73, // String type
0x00, 0x05, // String length
0x74, 0x65, 0x73, 0x74, 0x31 //test1
];
let mut photon = photon_decode::Photon::new();
let mut decoded = photon.try_decode(
&[&header[..], &photon_command[..], &message[..]].concat()).expect("Shold works").into_iter();
let msg = decoded.next().expect("Shold contain one msg").expect("Should decode event");
let parameters: Parameters =
[(0, Value::String("test1".to_owned()))]
.iter().cloned().collect();
assert_eq!(msg, Message::Event(EventData{ code: 100, parameters}));
}
#[test]
fn test_fragmented_event_message()
{
let header = vec![
0x00, 0x01, // PeerID
0x01, // CrcEnabled
0x01, // CommandCount
0x00, 0x00, 0x00, 0x01, // Timestamp
0x00, 0x00, 0x00, 0x01, // Challenge
];
let mut photon = photon_decode::Photon::new();
let photon_command = vec![
0x08, // Type
0x01, // ChannelID
0x01, // Flags
0x04, // ReservedByte
0x00, 0x00, 0x00, 0x22, // Length
0x00, 0x00, 0x00, 0x01, // ReliableSequenceNumber
0x00, 0x00, 0x00, 0x01, // SequenceNumber
0x00, 0x00, 0x00, 0x03, // FragmentCount
0x00, 0x00, 0x00, 0x01, // FragmentNumber
0x00, 0x00, 0x00, 0x1a, // TotalLength
0x00, 0x00, 0x00, 0x01, // OperationLength
];
let message = vec![
0x01, // ??
0x04, // MsgType (Event)
// Payload
];
let decoded = photon.decode(
&[&header[..], &photon_command[..], &message[..]].concat());
assert!(decoded.len() == 0);
let photon_command = vec![
0x08, // Type
0x01, // ChannelID
0x01, // Flags
0x04, // ReservedByte
0x00, 0x00, 0x00, 0x27, // Length
0x00, 0x00, 0x00, 0x01, // ReliableSequenceNumber
0x00, 0x00, 0x00, 0x01, // SequenceNumber
0x00, 0x00, 0x00, 0x03, // FragmentCount
0x00, 0x00, 0x00, 0x02, // FragmentNumber
0x00, 0x00, 0x00, 0x1a, // TotalLength
0x00, 0x00, 0x00, 0x01, // OperationLength
];
let message = vec![
// Payload
0x64, 0x00, 0x02, // Key
0x00, 0x73, // String type
0x00, 0x05, // String length
];
let decoded = photon.decode(
&[&header[..], &photon_command[..], &message[..]].concat());
assert!(decoded.len() == 0);
let photon_command = vec![
0x08, // Type
0x01, // ChannelID
0x01, // Flags
0x04, // ReservedByte
0x00, 0x00, 0x00, 0x25, // Length
0x00, 0x00, 0x00, 0x01, // ReliableSequenceNumber
0x00, 0x00, 0x00, 0x01, // SequenceNumber
0x00, 0x00, 0x00, 0x03, // FragmentCount
0x00, 0x00, 0x00, 0x03, // FragmentNumber
0x00, 0x00, 0x00, 0x1a, // TotalLength
0x00, 0x00, 0x00, 0x01, // OperationLength
];
let message = vec![
0x74, 0x65, 0x73, 0x74, 0x31 //test1
];
let decoded = photon.decode(
&[&header[..], &photon_command[..], &message[..]].concat());
assert_eq!(decoded.len(), 1);
let parameters: Parameters =
[(0, Value::String("test1".to_owned()))]
.iter().cloned().collect();
assert_eq!(decoded[0], Message::Event(EventData{ code: 100, parameters}));
}
#[test]
fn test_two_event_messages()
{
let payload = vec![
0x00, 0x00,
0x00,
0x02,
0x72, 0xe9, 0xe2, 0x84,
0x11, 0x63, 0x88, 0x88,
0x07,
0x00,
0x00,
0x00,
0x00, 0x00, 0x00, 0x45,
0x00, 0x00, 0x16, 0x8e,
0x00, 0x00, 0x45, 0x2b,
0xf3, 0x04, 0x02, 0x00, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa, 0xb7, 0x36, 0x01, 0x78, 0x00, 0x00, 0x00, 0x20, 0x03, 0x6b, 0xc9, 0x04, 0xc1, 0xe2, 0x62, 0xd7, 0x08, 0x6b, 0xb0, 0x91, 0xc1, 0x2a, 0x80, 0x1b, 0xc2, 0x26, 0x00, 0x00, 0xb0, 0x40, 0xd8, 0xe6, 0x53, 0xc1, 0x8f, 0xcd, 0xc, 0xc2, 0x00, 0x00,
0x06,
0x00,
0x01,
0x00,
0x00, 0x00, 0x00, 0x1b,
0x00, 0x00, 0x16, 0x8f,
0xf3, 0x04, 0x01, 0x00, 0x02, 0x00, 0x69, 0x00, 0xa, 0xf6, 0xdf, 0xfc, 0x6b, 0x00, 0x01
];
let mut photon = photon_decode::Photon::new();
let decoded = photon.decode(&payload);
assert!(decoded.len() == 2);
let parameters: Parameters =
[
(0x01, Value::ByteArray(vec![
3, 107, 201, 4, 193, 226, 98, 215, 8, 107, 176, 145, 193,
42, 128, 27, 194, 38, 0, 0, 176, 64, 216, 230, 83, 193,
143, 205, 12, 194, 0, 0])),
(0x00, Value::Long(702262))
]
.iter().cloned().collect();
assert_eq!(decoded[0], Message::Event(EventData{ code: 2, parameters}));
let parameters: Parameters =
[
(0x00, Value::Integer(718559)),
(0xfc, Value::Short(1))
]
.iter().cloned().collect();
assert_eq!(decoded[1], Message::Event(EventData{ code: 1, parameters}));
}
#[test]
fn test_request_message()
{
let payload = vec![
0x7d, 0xd3,
0x00,
0x01,
0x00, 0x04, 0xcc, 0xb6,
0x11, 0x63, 0x88, 0x88,
0x06,
0x00,
0x01,
0x04,
0x00, 0x00, 0x00, 0x2a,
0x00, 0x00, 0x00, 0x19,
0xf3, 0x02, 0x01, 0x00, 0x03, 0x00,
0x79, 0x00, 0x02, 0x66, 0xc1, 0xd3, 0x61, 0x20, 0xc2, 0x27, 0xc, 0xcd, 0x01, 0x62,
0x00, 0xfd, // key
0x73, // String type
0x00, 0x05, // String length
0x74, 0x65, 0x73, 0x74, 0x31 // test1
];
let mut photon = photon_decode::Photon::new();
let decoded = photon.decode(&payload);
assert!(decoded.len() == 1);
let parameters: Parameters =
[
(0x00, Value::Array(vec![Value::Float(-26.422424), Value::Float(-41.7625)])),
(0x01, Value::Byte(0)),
(0xfd, Value::String("test1".to_owned()))
]
.iter().cloned().collect();
assert_eq!(decoded[0], Message::Request(OperationRequest { code: 1, parameters}));
}
#[test]
fn test_response_message()
{
let payload = vec![
0x00, 0x00,
0x00,
0x02,
0x72, 0xea, 0x1d, 0x6a,
0x11, 0x63, 0x88, 0x88,
0x01,
0x00,
0x00,
0x00,
0x00, 0x00, 0x00, 0x14,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x24, 0x00, 0x04, 0xd7, 0x1a,
0x06,
0x00,
0x01,
0x00,
0x00, 0x00, 0x00, 0xb2,
0x00, 0x00, 0x17, 0x71,
0xf3, 0x03, 0x01, 0x00, 0x00, 0x2a, 0x00, 0xa, 0x00, 0x69, 0x18, 0xf2, 0x79, 0x68, 0x01, 0x73, 0x00, 0x5d, 0x40, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44, 0x40, 0x65, 0x66, 0x33, 0x37, 0x39, 0x34, 0x64, 0x61, 0x2d, 0x38, 0x66, 0x38, 0x33, 0x2d, 0x34, 0x33, 0x34, 0x30, 0x2d, 0x62, 0x66, 0x35, 0x32, 0x2d, 0x36, 0x38, 0x31, 0x31, 0x37, 0x61, 0x30, 0x36, 0x37, 0x32, 0x65, 0x34, 0x7c, 0x57, 0x65, 0x64, 0x72, 0x6f, 0x77, 0x79, 0x63, 0x7a, 0x4a, 0x61, 0x6b, 0x75, 0x62, 0x7c, 0x36, 0x33, 0x37, 0x30, 0x37, 0x35, 0x33, 0x37, 0x38, 0x38, 0x30, 0x33, 0x31, 0x38, 0x33, 0x39, 0x33, 0x35, 0x7c, 0x57, 0x65, 0x64, 0x72, 0x6f, 0x77, 0x79, 0x63, 0x7a, 0x4a, 0x61, 0x6b, 0x75, 0x62, 0x02, 0x79, 0x00, 0x00, 0x78, 0x03, 0x79, 0x00, 0x00, 0x73, 0x04, 0x79, 0x00, 0x00, 0x73, 0x05, 0x78, 0x00, 0x00, 0x00, 0x00, 0x06, 0x79, 0x00, 0x01, 0x79, 0x00, 0x01, 0x69, 0xff, 0xff, 0xff, 0xff, 0x07, 0x79, 0x00, 0x01, 0x79, 0x00, 0x01, 0x69, 0xff, 0xff, 0xff, 0xff, 0x08, 0x78, 0x00, 0x00, 0x00, 0x00, 0xfd, 0x6b, 0x00, 0xa6
];
let mut photon = photon_decode::Photon::new();
let decoded = photon.decode(&payload);
assert_eq!(decoded.len(), 1);
let parameters: Parameters =
[
(0x00, Value::Integer(418543976)),
(0x01, Value::String("@ISLAND@ef3794da-8f83-4340-bf52-68117a0672e4|WedrowyczJakub|637075378803183935|WedrowyczJakub".to_owned())),
(0x02, Value::Array(vec![])),
(0x03, Value::Array(vec![])),
(0x04, Value::Array(vec![])),
(0x05, Value::ByteArray(vec![])),
(0x06, Value::Array(vec![Value::Array(vec![Value::Integer(4294967295)])])),
(0x07, Value::Array(vec![Value::Array(vec![Value::Integer(4294967295)])])),
(0x08, Value::ByteArray(vec![])),
(0xFD, Value::Short(166)),
]
.iter().cloned().collect();
assert_eq!(decoded[0], Message::Response(OperationResponse { code: 1, return_code: 0, debug_message: "None".to_owned(), parameters}));
}
#[test]
fn test_example(){
use photon_decode::{Photon, Message};
let mut photon = Photon::new();
let photon_packet = vec![
0x00, 0x01, // PeerID
0x01, // CrcEnabled
0x00, // CommandCount
0x00, 0x00, 0x00, 0x01, // Timestamp
0x00, 0x00, 0x00, 0x01, // Challenge
];
for message in photon.decode(&photon_packet).iter() {
match message {
Message::Event(_) => {
// use event
},
Message::Request(_) => {
// use request
},
Message::Response(_) => {
// use response
}
}
}
}
+59
View File
@@ -0,0 +1,59 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use photon_decode::Photon;
use crate::game::World;
use crate::publisher::Publisher;
pub use crate::publisher::Subscribers;
use crate::translate::udp_packet_to_game_events;
pub enum InitializationError {
NetworkInterfaceListMissing,
}
pub fn initialize(subscribers: Subscribers) -> Result<(), InitializationError> {
initialize_logging();
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
let mut photon = Photon::new();
let mut world = World::new();
let mut publisher = Publisher::new(subscribers);
packet_sniffer::receive(interfaces, tx);
info!("Listening to network packets...");
loop {
if let Ok(packet) = rx.recv() {
udp_packet_to_game_events(&mut world, &mut photon, &packet)
.into_iter()
.for_each(|e| {
publisher.publish(&e);
});
}
}
});
} else {
return Err(InitializationError::NetworkInterfaceListMissing);
}
Ok(())
}
fn initialize_logging() {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Info,
Config::default(),
File::create("damage-meter.log").unwrap(),
)]).unwrap();
}
-639
View File
@@ -1,639 +0,0 @@
use std::fs::File;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread;
use log::*;
use simplelog::*;
use packet_sniffer::UdpPacket;
use photon_decode;
use photon_decode::Photon;
use crate::game_messages;
use crate::meter;
pub use meter::GameStats;
pub use meter::LastFightStats;
pub use meter::MeterConfig;
pub use meter::OverallStats;
pub use meter::PlayerEvents;
pub use meter::PlayerStatistics;
pub use meter::PlayerStatisticsVec;
pub use meter::ZoneStats;
pub use meter::StatType;
pub use crate::game_messages::Items;
pub enum InitializationError {
NetworkInterfaceListMissing,
}
lazy_static! {
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new());
}
pub fn stats(meter: &meter::Meter, stat_type: StatType) -> Vec<meter::PlayerStatistics> {
match stat_type {
StatType::Zone => meter
.zone_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
StatType::LastFight => meter
.last_fight_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
StatType::Overall => meter
.overall_stats()
.unwrap_or(meter::PlayerStatisticsVec::new())
.value(),
_ => vec![],
}
}
pub fn reset(meter: &mut meter::Meter, stat_type: StatType) {
match stat_type {
StatType::Zone => {
meter.reset_zone_stats();
}
StatType::LastFight => {
meter.reset_last_fight_stats();
}
StatType::Overall => {
meter.reset_stats();
}
_ => error!("Unexpected stat to reset."),
}
}
pub fn initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Info,
Config::default(),
File::create("damage-meter.log").unwrap(),
)])
.unwrap();
let meter = meter::Meter::new();
let meter = Arc::new(Mutex::new(meter));
let cloned_meter = meter.clone();
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
let mut photon = Photon::new();
packet_sniffer::receive(interfaces, tx);
info!("Listening to network packets...");
loop {
if let Ok(packet) = rx.recv() {
if packet.destination_port != 5056 && packet.source_port != 5056 {
continue;
}
if let Ok(ref mut meter) = cloned_meter.lock() {
let game_messages = photon
.decode(&packet.payload)
.into_iter()
.filter_map(game_messages::into_game_message)
.collect();
register_messages(meter, &game_messages);
}
}
}
});
} else {
return Err(InitializationError::NetworkInterfaceListMissing);
}
Ok(meter)
}
pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_messages::Message>) {
messages
.iter()
.for_each(|message| register_message(meter, &message));
}
fn register_message<Events>(events: &mut Events, message: &game_messages::Message)
where
Events: PlayerEvents,
{
info!("Found message {:?}", message);
match message {
game_messages::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()),
game_messages::Message::NewCharacter(msg) => {
events.register_player(&msg.character_name, msg.source);
events.register_item_update(msg.source, &msg.items);
},
game_messages::Message::CharacterEquipmentChanged(msg) => {
events.register_item_update(msg.source, &msg.items);
},
game_messages::Message::Join(msg) => {
events.register_main_player(&msg.character_name, msg.source)
}
game_messages::Message::HealthUpdate(msg) => events
.register_damage_dealt(msg.target, msg.value)
.unwrap_or(()),
game_messages::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate {
Some(_) => events.register_combat_leave(msg.source).unwrap_or(()),
None => events.register_combat_enter(msg.source).unwrap_or(()),
},
game_messages::Message::KnockedDown(msg) => events.register_combat_leave(msg.source).unwrap_or(()),
game_messages::Message::UpdateFame(msg) => events
.register_fame_gain(msg.source, msg.fame as f32 / 10000.0)
.unwrap_or(()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use game_messages::messages;
use game_messages::Items;
use game_messages::Message;
mod helpers {
use super::*;
pub fn init_() -> meter::Meter {
meter::Meter::new()
}
pub fn sleep(time: u64) {
use fake_clock::FakeClock;
FakeClock::advance_time(time);
}
}
trait Testing {
fn new(source: usize) -> Self;
}
trait NamedTesting {
fn new_named(name: &str, source: usize) -> Self;
}
trait ListNamedTesting {
fn new_list_of_named(names: &[&str], source: usize) -> Self;
}
trait SwitchableTesting {
fn enabled(source: usize) -> Self;
fn disabled(source: usize) -> Self;
}
impl NamedTesting for messages::NewCharacter {
fn new_named(name: &str, source: usize) -> Self {
Self {
source: source,
character_name: name.to_owned(),
health: 10.0,
max_health: 10.0,
energy: 1.0,
max_energy: 1.0,
items: Items::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
}
}
}
impl NamedTesting for messages::Join {
fn new_named(name: &str, source: usize) -> Self {
Self {
source: source,
character_name: name.to_owned(),
health: 10.0,
max_health: 10.0,
energy: 1.0,
max_energy: 1.0,
}
}
}
impl Testing for messages::NewCharacter {
fn new(source: usize) -> Self {
messages::NewCharacter::new_named("CH1", source)
}
}
impl Testing for messages::Join {
fn new(source: usize) -> Self {
messages::Join::new_named("MAIN_CH1", source)
}
}
impl Testing for messages::Leave {
fn new(source: usize) -> Self {
Self { source: source }
}
}
impl Testing for messages::HealthUpdate {
fn new(source: usize) -> Self {
Self {
source: 200,
target: source,
value: -10.0,
}
}
}
impl Testing for messages::UpdateFame {
fn new(source: usize) -> Self {
Self {
source: source,
fame: 1000000,
}
}
}
impl SwitchableTesting for messages::RegenerationHealthChanged {
fn enabled(source: usize) -> Self {
Self {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: Some(1.0),
}
}
fn disabled(source: usize) -> Self {
Self {
source: source,
health: 10.0,
max_health: 10.0,
regeneration_rate: None,
}
}
}
#[test]
fn test_empty_session() {
let meter = helpers::init_();
assert_eq!(stats(&meter, StatType::Zone).len(), 0);
}
#[test]
fn test_new_player_appears() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(messages::NewCharacter::new(1)),
);
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
}
#[test]
fn test_new_player_stats() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(messages::NewCharacter::new(1)),
);
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].player, "CH1");
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].time_in_combat, 0.0);
assert_eq!(zone_stats[0].dps, 0.0);
assert_eq!(zone_stats[0].seconds_in_game, 0.0);
assert_eq!(zone_stats[0].fame, 0.0);
assert_eq!(zone_stats[0].fame_per_minute, 0);
assert_eq!(zone_stats[0].fame_per_hour, 0);
}
#[test]
fn test_damage_aggregation() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(messages::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 20.0);
}
#[test]
fn test_new_player_damage() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(messages::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
}
#[test]
fn test_new_player_damage_reset() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::NewCharacter(messages::NewCharacter::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
reset(&mut meter, StatType::Zone);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
}
#[test]
fn test_zone_detection() {
let mut meter = helpers::init_();
register_message(
&mut meter,
&Message::Join(messages::Join::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
assert_eq!(zone_stats[0].player, "MAIN_CH1");
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
register_message(
&mut meter,
&Message::Join(messages::Join::new(2)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 0.0);
register_message(
&mut meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(2)),
);
register_message(
&mut meter,
&Message::HealthUpdate(messages::HealthUpdate::new(2)),
);
let zone_stats = stats(&meter, StatType::Zone);
assert_eq!(zone_stats[0].damage, 10.0);
}
macro_rules! main_character_enters {
($meter:expr, $name:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::Join(messages::Join::new_named($name, $id)),
);
};
}
macro_rules! character_enters {
($meter:expr, $name:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::NewCharacter(messages::NewCharacter::new_named($name, $id)),
);
};
}
macro_rules! attack {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(
$id,
)),
);
register_message(
&mut $meter,
&Message::HealthUpdate(messages::HealthUpdate::new($id)),
);
};
}
macro_rules! combat_leave {
($meter:expr, $id:expr) => {
register_message(
&mut $meter,
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::enabled(
$id,
)),
);
};
}
#[test]
fn test_two_players_in_the_zone() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
let zone_stats = stats(&meter, StatType::Zone);
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
}
#[test]
fn test_overall_damage() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 20.0);
}
#[test]
fn test_last_fight_damage() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
}
#[test]
fn test_last_fight_management() {
// session should be started when first player attacks
// damage should be 0 when all players were out of combat and some player attacks
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH1", 2);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 2);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
character_enters!(meter, "CH2", 3);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 0.0);
attack!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 1);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 2);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
combat_leave!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 10.0);
attack!(meter, 1);
combat_leave!(meter, 3);
let zone_stats = stats(&meter, StatType::LastFight);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.damage, 10.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
assert_eq!(player_stats.damage, 0.0);
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
assert_eq!(player_stats.damage, 0.0);
}
#[test]
fn test_fame_statistics() {
let mut meter = helpers::init_();
main_character_enters!(meter, "MAIN_CH1", 1);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 0);
helpers::sleep(1000 * 60);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 0);
register_message(
&mut meter,
&Message::UpdateFame(messages::UpdateFame::new(1)),
);
let zone_stats = stats(&meter, StatType::Zone);
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
assert_eq!(player_stats.fame_per_minute, 100);
}
}
+1
View File
@@ -0,0 +1 @@
pub mod python;
+142
View File
@@ -0,0 +1,142 @@
use cpython::PyObject;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::PyDict;
use crate::game::Event;
use crate::game::events;
use crate::game::StaticId;
use crate::photon_messages;
impl ToPyObject for Event {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
match self {
Event::MainPlayerAppeared(e) => {
event.set_item(py, "name", "MainPlayerAppeared".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
},
Event::PlayerAppeared(e) => {
event.set_item(py, "name", "PlayerAppeared".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
},
Event::ZoneChange => {
event.set_item(py, "name", "ZoneChange".into_py_object(py)).unwrap_or(());
},
Event::UpdateItems(e) => {
event.set_item(py, "name", "UpdateItems".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::DamageDone(e) => {
event.set_item(py, "name", "DamageDone".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::EnterCombat(e) => {
event.set_item(py, "name", "EnterCombat".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::LeaveCombat(e) => {
event.set_item(py, "name", "LeaveCombat".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::UpdateFame(e) => {
event.set_item(py, "name", "UpdateFame".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
Event::HealthReceived(e) => {
event.set_item(py, "name", "HealthReceived".into_py_object(py)).unwrap_or(());
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
}
}
event.into_object()
}
}
impl ToPyObject for StaticId {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
self.inner().into_py_object(py).into_object()
}
}
impl ToPyObject for events::Player {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "id", self.id.into_py_object(py)).unwrap_or(());
event.set_item(py, "name", self.name.clone().into_py_object(py)).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Damage {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "target", self.target.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Fame {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
event.into_object()
}
}
impl ToPyObject for events::Items {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let event = PyDict::new(py);
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
event.set_item(py, "value", self.value.clone().into_py_object(py)).unwrap_or(());
event.into_object()
}
}
macro_rules! set_dict_item {
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
{}
};
}
impl ToPyObject for photon_messages::Items {
type ObjectType = PyDict;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.to_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let items = PyDict::new(py);
set_dict_item!(py, items, self, weapon);
set_dict_item!(py, items, self, offhand);
set_dict_item!(py, items, self, helmet);
set_dict_item!(py, items, self, armor);
set_dict_item!(py, items, self, boots);
set_dict_item!(py, items, self, bag);
set_dict_item!(py, items, self, cape);
set_dict_item!(py, items, self, mount);
set_dict_item!(py, items, self, potion);
set_dict_item!(py, items, self, food);
items
}
}
+1
View File
@@ -0,0 +1 @@
pub mod convert;
+133
View File
@@ -0,0 +1,133 @@
use std::convert::From;
use crate::photon_messages::messages;
use super::events;
use super::player::{StaticId, PlayerName};
pub struct EventIntermediate<Msg> {
id: StaticId,
name: PlayerName,
message: Msg,
}
impl<Msg> EventIntermediate<Msg> {
pub fn new(
id: StaticId,
name: PlayerName,
message: Msg,
) -> Self {
Self {
id,
name,
message,
}
}
}
pub struct EventList {
value: Vec<events::Event>,
}
impl EventList {
pub fn new(list: Vec<events::Event>) -> Self {
Self { value: list }
}
pub fn values(self) -> Vec<events::Event> {
self.value
}
}
impl From<EventIntermediate<messages::NewCharacter>> for events::Event {
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
Self::PlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
})
}
}
impl From<EventIntermediate<messages::NewCharacter>> for EventList {
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
Self::new(vec![
events::Event::PlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
}),
events::Event::UpdateItems(events::Items {
source: intermediate.id,
value: intermediate.message.items,
}),
])
}
}
impl From<EventIntermediate<messages::Join>> for events::Event {
fn from(intermediate: EventIntermediate<messages::Join>) -> Self {
Self::MainPlayerAppeared(events::Player {
id: intermediate.id,
name: intermediate.message.character_name,
})
}
}
impl From<EventIntermediate<messages::HealthUpdate>> for events::Event {
fn from(intermediate: EventIntermediate<messages::HealthUpdate>) -> Self {
if intermediate.message.value < 0.0 {
return Self::DamageDone(events::Damage {
source: intermediate.id,
target: None,
value: f32::abs(intermediate.message.value),
});
}
Self::HealthReceived(events::Damage {
source: intermediate.id,
target: None,
value: intermediate.message.value,
})
}
}
impl From<EventIntermediate<messages::RegenerationHealthChanged>> for events::Event {
fn from(intermediate: EventIntermediate<messages::RegenerationHealthChanged>) -> Self {
match intermediate.message.regeneration_rate {
Some(_) => Self::LeaveCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
}),
None => Self::EnterCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
}),
}
}
}
impl From<EventIntermediate<messages::KnockedDown>> for events::Event {
fn from(intermediate: EventIntermediate<messages::KnockedDown>) -> Self {
Self::LeaveCombat(events::Player {
id: intermediate.id,
name: intermediate.name.into(),
})
}
}
impl From<EventIntermediate<messages::UpdateFame>> for events::Event {
fn from(intermediate: EventIntermediate<messages::UpdateFame>) -> Self {
Self::UpdateFame(events::Fame {
source: intermediate.id,
value: intermediate.message.fame as f32 / 10000.0,
})
}
}
impl From<EventIntermediate<messages::CharacterEquipmentChanged>> for events::Event {
fn from(intermediate: EventIntermediate<messages::CharacterEquipmentChanged>) -> Self {
Self::UpdateItems(events::Items {
source: intermediate.id,
value: intermediate.message.items,
})
}
}
+43
View File
@@ -0,0 +1,43 @@
#![allow(dead_code)]
use crate::photon_messages;
use super::player::StaticId;
#[derive(Debug, Clone, PartialEq)]
pub struct Player {
pub id: StaticId,
pub name: String,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Damage {
pub source: StaticId,
pub target: Option<StaticId>,
pub value: f32,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Fame {
pub source: StaticId,
pub value: f32,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Items {
pub source: StaticId,
pub value: photon_messages::Items,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Event {
MainPlayerAppeared(Player),
PlayerAppeared(Player),
DamageDone(Damage),
HealthReceived(Damage),
ZoneChange,
EnterCombat(Player),
LeaveCombat(Player),
UpdateFame(Fame),
UpdateItems(Items),
}
+112
View File
@@ -0,0 +1,112 @@
#![allow(dead_code)]
use bimap::BiMap;
use std::collections::HashMap;
use super::player::{StaticId, DynamicId, PlayerName};
#[derive(Debug, PartialEq, Default)]
pub struct IdCache {
name_to_static_id: HashMap<String, u32>,
dyn_id_to_name: BiMap<u32, String>,
last_id: u32,
}
impl IdCache {
pub fn new() -> Self {
Self {
..Default::default()
}
}
pub fn save(&mut self, dynamic_id: DynamicId, name: &str) {
if self.name_to_static_id.get(name).is_none() {
let id = self.last_id;
self.last_id += 1;
self.name_to_static_id.insert(name.to_owned(), id);
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
}
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
}
pub fn get_static_id(&self, dynamic_id: DynamicId) -> Option<StaticId> {
self.dyn_id_to_name
.get_by_left(&dynamic_id.into())
.map(|name| {
self.name_to_static_id
.get(name)
.map(|v| *v)
.map(|v| v.into())
})
.flatten()
}
pub fn get_name(&self, static_id: StaticId) -> Option<PlayerName> {
self.name_to_static_id
.iter()
.find(|(_k, v)| **v == StaticId::into(static_id))
.map(|v| v.0)
.map(|v| v.clone().into())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_id_cache() {
let mut cache = IdCache::new();
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
cache.save(DynamicId::from(1), "test");
assert!(cache.get_static_id(DynamicId::from(1)).is_some());
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
cache.save(DynamicId::from(2), "test");
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(0)));
}
#[test]
fn test_if_id_is_unique_for_a_player() {
let mut cache = IdCache::new();
cache.save(DynamicId::from(1), "test");
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
cache.save(DynamicId::from(2), "test2");
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
cache.save(DynamicId::from(12345), "test3");
assert_eq!(cache.get_static_id(DynamicId::from(12345)), Some(StaticId::from(2)));
}
#[test]
fn test_finding_player_name() {
let mut cache = IdCache::new();
assert!(cache.get_name(StaticId::from(1)).is_none());
cache.save(DynamicId::from(1), "test");
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
assert_eq!(
cache.get_name(StaticId::from(0)),
Some(PlayerName::from("test".to_owned()))
);
cache.save(DynamicId::from(2), "test2");
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
assert_eq!(
cache.get_name(StaticId::from(1)),
Some(PlayerName::from("test2".to_owned()))
);
assert_eq!(
cache.get_name(StaticId::from(0)),
Some(PlayerName::from("test".to_owned()))
);
}
}
+11
View File
@@ -0,0 +1,11 @@
pub mod events;
pub mod convert;
pub mod world;
pub mod id_cache;
mod unconsumed_messages;
mod player;
pub use player::StaticId;
pub use events::*;
pub use world::World;
+16
View File
@@ -0,0 +1,16 @@
use derive_more::{From, Into};
#[derive(Copy, Clone, Debug, PartialEq, From, Into, Default)]
pub struct DynamicId(u32);
#[derive(Copy, Clone, Debug, PartialEq, From, Into)]
pub struct StaticId(u32);
#[derive(Debug, PartialEq, From, Into, Default)]
pub struct PlayerName(String);
impl StaticId {
pub fn inner(&self) -> u32 {
self.0
}
}
+23
View File
@@ -0,0 +1,23 @@
use super::player::{DynamicId};
use crate::photon_messages::Message;
use std::collections::HashMap;
#[derive(Debug, PartialEq, Default)]
pub struct UnconsumedMessages{
messages: HashMap<u32, Vec<Message>>
}
impl UnconsumedMessages {
pub fn add(&mut self, msg: Message, id: DynamicId) {
self.messages.entry(id.into()).or_insert(vec![]).push(msg);
}
pub fn get_for_id(&mut self, id: DynamicId) -> Option<Vec<Message>> {
let messages = self.messages.get(&id.into())?;
let result = messages.clone();
self.messages.remove(&id.into());
return Some(result);
}
}
+333
View File
@@ -0,0 +1,333 @@
//! Holds state of the game gathered from photon decoded packets.
//! Note: This module is responsible for resolving all inconsistency between photon events and required game events.
//!
//! Inconsistency list:
//! - player id is different in each zone
use crate::photon_messages;
use super::events;
use super::convert;
use super::convert::EventList;
use super::id_cache;
use super::player::{StaticId, DynamicId};
use super::unconsumed_messages::UnconsumedMessages;
#[derive(Debug, Default)]
pub struct World {
cache: id_cache::IdCache,
unconsumed_messages: UnconsumedMessages,
main_player_id: Option<StaticId>,
}
impl World {
pub fn new() -> Self {
Self {
..Default::default()
}
}
/// Transforms inconsistent game message into corresponding list of game events
pub fn transform(
&mut self,
message: photon_messages::Message,
) -> Option<Vec<events::Event>> {
match message {
photon_messages::Message::NewCharacter(msg) => {
let mut result = vec![];
let dynamic_id = DynamicId::from(msg.source as u32);
self.assign_dynamic_id(dynamic_id, &msg.character_name);
let static_id = self.get_static_id(msg.source)?;
result.append(&mut EventList::from(self.get_intermediate(static_id, msg)?).values());
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
for message in messages {
result.append(&mut self.transform(message).unwrap_or(vec![]));
}
}
Some(result)
}
photon_messages::Message::Join(msg) => {
let mut result = vec![];
let dynamic_id = DynamicId::from(msg.source as u32);
self.assign_dynamic_id(dynamic_id, &msg.character_name);
let static_id = self.get_static_id(msg.source)?;
if self.main_player_id.is_none() {
result.push(events::Event::ZoneChange)
}
result.push(self.get_intermediate(static_id, msg)?.into());
self.main_player_id = Some(static_id);
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
for message in messages {
result.append(&mut self.transform(message).unwrap_or(vec![]));
}
}
Some(result)
}
photon_messages::Message::Leave(msg) => {
let static_id = self.get_static_id(msg.source)?;
if let Some(main_player_id) = self.main_player_id {
if main_player_id == static_id {
return Some(vec![events::Event::ZoneChange]);
}
}
None
}
photon_messages::Message::HealthUpdate(msg) => {
let static_id = self.get_static_id(msg.target)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::RegenerationHealthChanged(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::KnockedDown(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::UpdateFame(msg) => {
let static_id = self.get_static_id(msg.source)?;
Some(vec![self.get_intermediate(static_id, msg)?.into()])
}
photon_messages::Message::CharacterEquipmentChanged(msg) => {
if let Some(static_id) = self.get_static_id(msg.source) {
return Some(vec![self.get_intermediate(static_id, msg)?.into()]);
}
let id = DynamicId::from(msg.source as u32);
self.unconsumed_messages.add(
photon_messages::messages::Message::CharacterEquipmentChanged(msg), id);
None
}
}
}
fn assign_dynamic_id(&mut self, id: DynamicId, name: &str) {
self.cache.save(id, name);
}
fn get_static_id(&self, id: usize) -> Option<StaticId> {
let dynamic_id = DynamicId::from(id as u32);
self.cache.get_static_id(dynamic_id) // queue message if static id isn't known
}
fn get_intermediate<Msg>(
&self,
static_id: StaticId,
msg: Msg,
) -> Option<convert::EventIntermediate<Msg>> {
Some(convert::EventIntermediate::new(
static_id,
self.cache.get_name(static_id)?,
msg,
))
}
}
#[cfg(test)]
mod tests {
use super::*;
macro_rules! assert_contains {
($container:expr, $value:expr) => {
assert!(
format!("{:?}", $container).contains($value),
format!("{:?} does not contains {}", $container, $value)
);
};
}
macro_rules! simulate_new_player {
($id:expr, $name:expr, $msg:ident) => {
photon_messages::Message::$msg(photon_messages::messages::$msg {
source: $id,
character_name: $name.to_string(),
..Default::default()
});
};
}
#[test]
/// photon_messages::NewCharacter -> events::Event::PlayerAppeared
fn test_player_appeared() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", NewCharacter);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
}
#[test]
/// photon_messages::Join -> Event::PlayerAppeared
fn test_main_player_appeared() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
}
#[test]
/// photon_messages::HealthUpdate -> Event::DamageDone | Event::HealthReceived
fn test_damage_done() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
let target = 1;
let game_message =
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
target,
value: -666.0,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(world.transform(game_message.clone()), "DamageDone");
assert_contains!(world.transform(game_message.clone()), "-666");
let target = 1;
let game_message =
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
target,
value: 666.0,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"HealthReceived"
);
assert_contains!(world.transform(game_message.clone()), "666");
}
#[test]
/// photon_messages::Leave -> Event::ZoneChange
fn test_zone_change() {
let mut world = World::new();
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_none());
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
assert_contains!(
world.transform(game_message.clone()),
"PlayerAppeared"
);
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "ZoneChange");
let game_message = simulate_new_player!(2, "TestCharacter", NewCharacter);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
source: 1,
..Default::default()
});
assert!(world.transform(game_message.clone()).is_none());
}
#[test]
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::LeaveCombat
fn test_combat_leave_via_regeneration_change() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::RegenerationHealthChanged(
photon_messages::messages::RegenerationHealthChanged {
source: 1,
regeneration_rate: Some(1.0),
..Default::default()
},
);
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
}
#[test]
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::EnterCombat
fn test_combat_enter_via_regeneration_change() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message = photon_messages::Message::RegenerationHealthChanged(
photon_messages::messages::RegenerationHealthChanged {
source: 1,
regeneration_rate: None,
..Default::default()
},
);
assert_contains!(world.transform(game_message.clone()), "EnterCombat");
}
#[test]
/// photon_messages::KnockedDown -> Event::EnterCombat
fn test_combat_enter_via_knockout() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message =
photon_messages::Message::KnockedDown(photon_messages::messages::KnockedDown {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
}
#[test]
/// photon_messages::UpdateFame -> Event::FameUpdate
fn test_fame_update() {
let mut world = World::new();
let game_message = simulate_new_player!(1, "TestCharacter", Join);
assert!(world.transform(game_message.clone()).is_some());
let game_message =
photon_messages::Message::UpdateFame(photon_messages::messages::UpdateFame {
source: 1,
..Default::default()
});
assert_contains!(world.transform(game_message.clone()), "UpdateFame");
}
}
-200
View File
@@ -1,200 +0,0 @@
#[macro_use]
extern crate cpython;
#[macro_use]
extern crate lazy_static;
pub mod game_messages;
mod meter;
mod core;
use std::sync::{Mutex, Arc};
use log::*;
use cpython::PyList;
use cpython::PyObject;
use cpython::PyResult;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::FromPyObject;
use cpython::PyDict;
use crate::core::StatType;
use crate::core::InitializationError;
struct PyMeter
{
value: Option<Arc<Mutex<meter::Meter>>>
}
impl PyMeter
{
fn new() -> Self {
Self{value: None}
}
fn initialize(&mut self, value: Arc<Mutex<meter::Meter>>) {
self.value = Some(value);
}
fn get(&mut self) -> Option<Arc<Mutex<meter::Meter>>> {
self.value.clone()
}
}
lazy_static! {
static ref METER: Mutex<PyMeter> = Mutex::new(PyMeter::new());
}
macro_rules! set_dict_item {
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
{}
};
}
impl ToPyObject for core::PlayerStatistics {
type ObjectType = PyObject;
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let stats = PyDict::new(py);
set_dict_item!(py, stats, self, player);
set_dict_item!(py, stats, self, damage);
set_dict_item!(py, stats, self, time_in_combat);
set_dict_item!(py, stats, self, dps);
set_dict_item!(py, stats, self, seconds_in_game);
set_dict_item!(py, stats, self, fame);
set_dict_item!(py, stats, self, fame_per_minute);
set_dict_item!(py, stats, self, fame_per_hour);
set_dict_item!(py, stats, self, items);
stats.into_object()
}
}
impl ToPyObject for core::PlayerStatisticsVec {
type ObjectType = PyList;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.value().into_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
self.value().into_py_object(py)
}
}
impl ToPyObject for core::Items {
type ObjectType = PyDict;
fn into_py_object(self, py: Python) -> Self::ObjectType {
self.to_py_object(py)
}
fn to_py_object(&self, py: Python) -> Self::ObjectType {
let items = PyDict::new(py);
set_dict_item!(py, items, self, weapon);
set_dict_item!(py, items, self, offhand);
set_dict_item!(py, items, self, helmet);
set_dict_item!(py, items, self, armor);
set_dict_item!(py, items, self, boots);
set_dict_item!(py, items, self, bag);
set_dict_item!(py, items, self, cape);
set_dict_item!(py, items, self, mount);
set_dict_item!(py, items, self, potion);
set_dict_item!(py, items, self, food);
items
}
}
impl <'source> FromPyObject<'source> for StatType {
fn extract(py: Python, obj: &'source PyObject) -> PyResult<Self> {
match obj.extract(py) {
Ok(n) => {
match n {
1 => Ok(StatType::LastFight),
2 => Ok(StatType::Zone),
3 => Ok(StatType::Overall),
_ => Ok(StatType::Unknown)
}
},
Err(e) => Err(e)
}
}
}
pub fn stats(py: Python, stat_type: StatType) -> PyResult<PyDict> {
let stats = PyDict::new(py);
if let Ok(ref mut py_meter) = METER.lock() {
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
let mut main : Option<core::PlayerStatistics> = None;
stats.set_item(py, "players", core::stats(&meter, stat_type)
.into_iter()
.inspect(|s| {
if s.main_player_stats {
main = Some(s.clone());
}
})
.filter(|s| !s.idle || s.fame != 0.0)
.collect::<Vec<meter::PlayerStatistics>>()
.into_py_object(py)).ok();
stats.set_item(py, "main", main.into_py_object(py)).ok();
return Ok(stats);
}
}
}
error!("Failed to acquire locks on meter");
Ok(stats)
}
pub fn reset(_py: Python, stat_type: StatType) -> PyResult<u32> {
if let Ok(ref mut py_meter) = METER.lock() {
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
core::reset(meter, stat_type);
return Ok(0);
}
}
}
error!("Failed to acquire locks on meter");
Ok(1)
}
fn initialize(_py: Python) -> PyResult<u32> {
if let Ok(ref mut py_meter) = METER.lock() {
match core::initialize() {
Ok(core_meter) => py_meter.initialize(core_meter),
Err(InitializationError::NetworkInterfaceListMissing) => return Ok(2)
};
if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() {
meter.configure(core::MeterConfig {
..Default::default()
});
return Ok(0);
}
}
}
error!("Failed to initialize meter");
Ok(1)
}
py_module_initializer!(libaostats, initlibaostats, PyInit_libaostats, |py, m| {
m.add(py, "__doc__", "This module is implemented in Rust")?;
m.add(py, "initialize", py_fn!(py, initialize()))?;
m.add(py, "stats", py_fn!(py, stats(stat_type: StatType)))?;
m.add(py, "reset", py_fn!(py, reset(stat_type: StatType)))?;
Ok(())
});
+64
View File
@@ -0,0 +1,64 @@
#[macro_use]
extern crate cpython;
#[macro_use]
extern crate lazy_static;
mod photon_messages;
mod game;
mod translate;
mod publisher;
mod crosslang;
mod api;
use std::sync::Mutex;
use log::*;
use cpython::PyResult;
use cpython::Python;
use cpython::ToPyObject;
use cpython::PythonObject;
use cpython::ObjectProtocol;
use cpython::PyTuple;
lazy_static! {
static ref PY_CALLBACKS: Mutex<Vec<cpython::PyObject>> = Mutex::new(Vec::new());
}
fn python_callbacks_subscriber(event: game::Event) {
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
let gil = Python::acquire_gil();
let py = gil.python();
for py_callback in py_callbacks.iter() {
let py_args = [event.clone().into_py_object(py).into_object()];
let args = PyTuple::new(py, &py_args[..]);
if let Some(error) = py_callback.call(py, args, None).err() {
error!("{:?}", error);
}
}
}
}
fn initialize(_py: Python) -> PyResult<u32> {
api::initialize(vec![
Box::new(python_callbacks_subscriber)
]).map_or(Ok(0), |_| {Ok(2)})
}
fn subscribe(_py: Python, callable: cpython::PyObject) -> PyResult<u32> {
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
py_callbacks.push(callable);
}
Ok(0)
}
py_module_initializer!(libaostats, initlibaostats, PyInit_libaostats, |py, m| {
m.add(py, "__doc__", "This module is implemented in Rust")?;
m.add(py, "initialize", py_fn!(py, initialize()))?;
m.add(py, "subscribe", py_fn!(py, subscribe(callable: cpython::PyObject)))?;
Ok(())
});
+122 -134
View File
@@ -10,9 +10,10 @@ mod traits;
mod types; mod types;
mod session; mod session;
use crate::game::Event;
use player::Player; use player::Player;
pub use super::game_messages; use super::photon_messages;
pub use traits::*; pub use traits::*;
pub use types::*; pub use types::*;
@@ -21,29 +22,138 @@ use session::Session;
#[derive(Default)] #[derive(Default)]
pub struct MeterConfig {} pub struct MeterConfig {}
#[derive(Default)]
pub struct Meter { pub struct Meter {
zone_history: PlayerStatisticsVec, zone_history: PlayerStatisticsVec,
zone_session: Option<Session>, zone_session: Option<Session>,
last_fight_session: Session, last_fight_session: Session,
main_player_id: Option<usize>, unconsumed_items: HashMap<usize, photon_messages::Items>,
unconsumed_items: HashMap<usize, game_messages::Items>,
config: MeterConfig,
} }
impl Meter { impl Meter {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
zone_history: PlayerStatisticsVec::new(), ..Default::default()
zone_session: None,
last_fight_session: Session::new(),
main_player_id: None,
unconsumed_items: HashMap::new(),
config: Default::default(),
} }
} }
pub fn configure(&mut self, config: MeterConfig) { pub fn consume(&mut self, event: Event) -> Option<()> {
self.config = config; 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 { fn stats_filter(&self, _player: &(&String, &Player)) -> bool {
@@ -90,7 +200,6 @@ impl Meter {
self.last_fight_session = Session::new(); self.last_fight_session = Session::new();
} }
#[allow(unused)]
fn combat_state(&self) -> CombatState { fn combat_state(&self) -> CombatState {
if self if self
.last_fight_session .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 { impl LastFightStats for Meter {
fn last_fight_stats(&self) -> Option<PlayerStatisticsVec> { fn last_fight_stats(&self) -> Option<PlayerStatisticsVec> {
let last_session = &self.last_fight_session; let last_session = &self.last_fight_session;
@@ -266,13 +264,3 @@ impl GameStats for Meter {
Some(()) Some(())
} }
} }
#[test]
fn test_meter() {
let mut meter = Meter::new();
assert_eq!(meter.zone_stats(), None);
meter.register_main_player("name", 0);
assert!(meter.zone_stats().is_some());
}
+1 -1
View File
@@ -3,7 +3,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))] #[cfg(not(test))]
use std::time::Instant; use std::time::Instant;
use super::game_messages::Items; use super::photon_messages::Items;
use super::traits::CombatState; use super::traits::CombatState;
use super::traits::DamageDealer; use super::traits::DamageDealer;
+1 -13
View File
@@ -12,7 +12,7 @@ use super::player::Player;
use super::traits::CombatState; use super::traits::CombatState;
use super::types::PlayerStatisticsVec; use super::types::PlayerStatisticsVec;
#[derive(Debug)] #[derive(Debug, Default)]
pub struct Session { pub struct Session {
players: HashMap<String, Player>, 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> { pub fn players(&self) -> Vec<&Player> {
self.players.iter().map(|(_, p)| p).collect() self.players.iter().map(|(_, p)| p).collect()
} }
+1 -51
View File
@@ -4,7 +4,7 @@ use fake_clock::FakeClock as Instant;
use std::time::Instant; use std::time::Instant;
use super::types::PlayerStatisticsVec; use super::types::PlayerStatisticsVec;
use super::game_messages::Items; use super::photon_messages::Items;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum CombatState { pub enum CombatState {
@@ -61,56 +61,6 @@ pub trait ItemCarrier {
fn items(&self) -> Items; 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 { pub trait LastFightStats {
fn last_fight_stats(&self) -> Option<PlayerStatisticsVec>; fn last_fight_stats(&self) -> Option<PlayerStatisticsVec>;
fn reset_last_fight_stats(&mut self) -> Option<()>; fn reset_last_fight_stats(&mut self) -> Option<()>;
+2 -2
View File
@@ -5,7 +5,7 @@ use fake_clock::FakeClock as Instant;
#[cfg(not(test))] #[cfg(not(test))]
use std::time::Instant; use std::time::Instant;
use super::game_messages::Items; use super::photon_messages::Items;
use super::traits::DamageStats; use super::traits::DamageStats;
use super::traits::FameStats; use super::traits::FameStats;
@@ -24,7 +24,7 @@ pub struct PlayerStatistics {
pub main_player_stats: bool, pub main_player_stats: bool,
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone, Default)]
pub struct PlayerStatisticsVec { pub struct PlayerStatisticsVec {
_vec: Vec<PlayerStatistics>, _vec: Vec<PlayerStatistics>,
} }
@@ -1,5 +1,5 @@
use log::*; use log::*;
use crate::game_messages::Items; use crate::photon_messages::Items;
use photon_decode::Parameters; use photon_decode::Parameters;
use photon_decode::Value; use photon_decode::Value;
@@ -114,7 +114,7 @@ macro_rules! decode_float {
}; };
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct Leave { pub struct Leave {
pub source: usize, pub source: usize,
@@ -130,7 +130,7 @@ impl Leave {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct HealthUpdate { pub struct HealthUpdate {
pub source: usize, pub source: usize,
pub target: usize, pub target: usize,
@@ -150,7 +150,7 @@ impl HealthUpdate {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct RegenerationHealthChanged { pub struct RegenerationHealthChanged {
pub source: usize, pub source: usize,
pub health: f32, pub health: f32,
@@ -172,7 +172,7 @@ impl RegenerationHealthChanged {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct KnockedDown { pub struct KnockedDown {
pub source: usize, pub source: usize,
pub target: usize, pub target: usize,
@@ -192,7 +192,7 @@ impl KnockedDown {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct NewCharacter { pub struct NewCharacter {
pub source: usize, pub source: usize,
pub character_name: String, pub character_name: String,
@@ -221,7 +221,7 @@ impl NewCharacter {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct UpdateFame { pub struct UpdateFame {
pub source: usize, pub source: usize,
pub fame: usize, pub fame: usize,
@@ -239,7 +239,7 @@ impl UpdateFame {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct CharacterEquipmentChanged { pub struct CharacterEquipmentChanged {
pub source: usize, pub source: usize,
pub items: Items, pub items: Items,
@@ -258,7 +258,7 @@ impl CharacterEquipmentChanged {
} }
} }
#[derive(Debug, Default)] #[derive(Debug, Clone, PartialEq, Default)]
pub struct Join { pub struct Join {
pub source: usize, pub source: usize,
pub character_name: String, pub character_name: String,
@@ -284,7 +284,7 @@ impl Join {
} }
} }
#[derive(Debug)] #[derive(Debug, Clone, PartialEq)]
pub enum Message { pub enum Message {
Leave(Leave), Leave(Leave),
HealthUpdate(HealthUpdate), HealthUpdate(HealthUpdate),
+49
View File
@@ -0,0 +1,49 @@
use crate::game::Event;
pub type Subscriber = dyn FnMut(Event) + Send;
pub type Subscribers = Vec<Box<Subscriber>>;
#[derive(Default)]
pub struct Publisher {
subscribers: Subscribers
}
impl Publisher {
pub fn new(subscribers: Subscribers) -> Self {
Self {subscribers, ..Default::default()}
}
pub fn publish(&mut self, event: &Event) {
for subscriber in &mut self.subscribers {
subscriber(event.clone());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::thread;
#[test]
fn test_simple_subscription() {
let subscriber = |_| {};
let mut publisher = Publisher::new(vec![Box::new(subscriber)]);
publisher.publish(&Event::ZoneChange);
}
pub fn test_call_in_the_thread(subscribers: Subscribers)
{
thread::spawn(move || {
let mut publisher = Publisher::new(subscribers);
});
}
#[test]
fn test_threads() {
test_call_in_the_thread(vec![]);
}
}
+42
View File
@@ -0,0 +1,42 @@
use packet_sniffer::UdpPacket;
use photon_decode::Photon;
use crate::game::Event;
use crate::photon_messages::into_game_message;
use crate::photon_messages::Message;
use crate::game::World;
use log::*;
static GAME_PORT : u16 = 5056;
pub fn udp_packet_to_game_events(game_world: &mut World, photon: &mut Photon, packet: &UdpPacket) -> Vec<Event> {
if ! is_packet_valid(packet) {
return vec![]
}
debug!("Raw payload: {:?}", &packet.payload);
raw_to_photon_messages(photon, &packet.payload)
.into_iter()
.map(|message| game_world.transform(message))
.flatten()
.flatten()
.collect()
}
fn raw_to_photon_messages(photon: &mut Photon, packet_payload: &[u8]) -> Vec<Message> {
return photon
.decode(packet_payload)
.into_iter()
.filter_map(into_game_message)
.collect()
}
fn is_packet_valid(packet: &UdpPacket) -> bool {
return packet.destination_port == GAME_PORT || packet.source_port == GAME_PORT;
}
#[cfg(test)]
mod tests {
}
-2
View File
@@ -1,2 +0,0 @@
from .app import run
-215
View File
@@ -1,215 +0,0 @@
import os
try:
import aostats
except:
class aostats:
@staticmethod
def initialize(_):
return InitializationResult.NetworkInterfaceListMissing
@staticmethod
def stats(_):
return {
'players': [],
'main': None
}
from .config import config
from .number import Number
TESTING_ENABLED = bool(os.getenv('TESTING'))
class StatType:
Unknown = 0
LastFight = 1
Zone = 2
Overall = 3
class InitializationResult:
Ok = 0
UnknownFailure = 1
NetworkInterfaceListMissing = 2
INITIALIZATION_RESULT = {
0: InitializationResult.Ok,
1: InitializationResult.UnknownFailure,
2: InitializationResult.NetworkInterfaceListMissing
}
class DamageStat:
def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage):
self.name = name
self.items = items
self.damage = Number(damage)
self.time_in_combat = Number(time_in_combat)
self.dps = Number(dps)
self.percentage = Number(percentage)
self.best_damage = Number(best_damage)
def __str__(self):
return "Name {} Damage {} DPS {} percentage {} items {}".format(self.name, self.damage, self.dps, self.percentage, self.items)
def __eq__(self, other):
return self.name == other.name and self.damage == other.damage and self.time_in_combat == other.time_in_combat and self.dps == other.dps
class FameStat:
def __init__(self, fame, fame_per_hour):
self.fame = fame
self.fame_per_hour = fame_per_hour
def stats(session, with_dmg=False):
players = session['players']
main_player = session['main']
with_damage = [s for s in players if s['damage']
!= 0.0] if with_dmg else players
extended_session = with_percentage(with_damage)
statistics = [DamageStat(
s['player'],
s['items'],
s['damage'],
s['time_in_combat'],
s['dps'],
s['dmg_percentage'],
s['best_damage']) for s in extended_session]
elapsed = 0
fame = FameStat(Number(0.0), Number(0.0))
if main_player:
if 'fame' in main_player:
fame = FameStat(Number(main_player['fame']), Number(
main_player['fame_per_hour']))
if 'seconds_in_game' in main_player:
elapsed = main_player['seconds_in_game']
return statistics, fame, elapsed
def with_percentage(session):
best_damage = 0.0
damage_done = 0.0
for s in session:
damage = s['damage']
if damage > best_damage:
best_damage = damage
damage_done += damage
for s in session:
s['dmg_percentage'] = s['damage'] / \
damage_done * 100 if s['damage'] else 0.0
s['best_damage'] = best_damage
return session
def zone_stats(with_damage=False):
if TESTING_ENABLED:
session = {
'players': [
{'player': 'Arcane', 'damage': 200.0, 'time_in_combat': 12.0, 'dps': 142.4234, 'fame': 20.0, 'fame_per_hour': 30, 'items': {
'weapon': 'T4_MAIN_ARCANESTAFF@3'
}},
{'player': 'Cursed', 'damage': 1100.0, 'time_in_combat': 12.0, 'dps': 222, 'items': {
'weapon': 'T5_MAIN_CURSEDSTAFF@2'
}},
{'player': 'Fire', 'damage': 775.0, 'time_in_combat': 12.0, 'dps': 132, 'items': {
'weapon': 'T5_MAIN_FIRESTAFF@1'
}},
{'player': 'Frost', 'damage': 2800.0, 'time_in_combat': 12.0, 'dps': 743, 'items': {
'weapon': 'T5_MAIN_FROSTSTAFF@1'
}},
{'player': 'Holy', 'damage': 500.0, 'time_in_combat': 12.0, 'dps': 99, 'items': {
'weapon': 'T6_MAIN_HOLYSTAFF'
}},
{'player': 'Nature', 'damage': 500.0, 'time_in_combat': 12.0, 'dps': 123, 'items': {
'weapon': 'T8_MAIN_NATURESTAFF@3'
}},
{'player': 'Axe', 'damage': 2430.0, 'time_in_combat': 120.0, 'dps': 631, 'items': {
'weapon': 'T8_MAIN_AXE'
}},
{'player': 'Dagger', 'damage': 1900.0, 'time_in_combat': 12.0, 'dps': 551, 'items': {
'weapon': 'T8_MAIN_DAGGER@2'
}},
{'player': 'Hammer', 'damage': 500.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T7_MAIN_HAMMER@2'
}},
{'player': 'Mace', 'damage': 500.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T6_MAIN_MACE@2'
}},
{'player': 'Quarterstaff', 'damage': 250.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T5_2H_IRONCLADEDSTAFF'
}},
{'player': 'Spear', 'damage': 250.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T8_MAIN_SPEAR@2'
}},
{'player': 'Sword', 'damage': 250.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T7_2H_CLAYMORE@1'
}},
{'player': 'Bow', 'damage': 250.0, 'time_in_combat': 12.0, 'dps': 13, 'items': {
'weapon': 'T8_2H_BOW'
}},
{'player': 'Crossbow', 'damage': 1800.0, 'time_in_combat': 450.0, 'dps': 450, 'items': {
'weapon': 'T8_2H_CROSSBOWLARGE@3'
}},
],
'main': {'player': 'Crossbow', 'damage': 250.0, 'time_in_combat': 120000.0, 'dps': 13, 'items': {
'weapon': 'T8_2H_CROSSBOWLARGE@3'
}, 'fame': 2300000, 'fame_per_hour': 46000.0, 'seconds_in_game': 3000}
}
else:
session = aostats.stats(StatType.Zone)
return stats(session, with_damage)
def overall_stats(with_damage=False):
if TESTING_ENABLED:
session = {'players': [
{'player': 'overall', 'damage': 1000.0,
'time_in_combat': 12.0, 'dps': 12.4234, 'items': {'weapon': 'T8_2H_CROSSBOWLARGE@3'}},
], 'main': {}}
else:
session = aostats.stats(StatType.Overall)
return stats(session, with_damage)
def last_fight_stats(with_damage=False):
if TESTING_ENABLED:
session = {'players': [
{'player': 'last', 'damage': 1000.0,
'time_in_combat': 12.0, 'dps': 12.4234, 'items': {'weapon': 'T8_2H_CROSSBOWLARGE@3'}},
], 'main': {}}
else:
session = aostats.stats(StatType.LastFight)
return stats(session, with_damage)
def reset_zone_stats():
aostats.reset(StatType.Zone)
def reset_last_fight_stats():
aostats.reset(StatType.LastFight)
def reset_stats():
aostats.reset(StatType.Overall)
def initialize():
if TESTING_ENABLED:
return InitializationResult.Ok
cfg = config()
try:
return INITIALIZATION_RESULT[aostats.initialize()]
except:
pass
+6 -6
View File
@@ -1,8 +1,8 @@
#!/bin/bash #!/bin/bash
# Helper script used to generate # Helper script used to generate
# - frontend/src/assets/item_category_map.json # - application/src/assets/item_category_map.json
# - frontend/src/assets/localization.json # - application/src/assets/localization.json
# - backend/assets/item_ids.txt # - backend/assets/item_ids.txt
# Args: path to directory containing files generated by ao-id-extractor # Args: path to directory containing files generated by ao-id-extractor
# Usage python scripts/generate_assets.sh ${EXTRACTED} # Usage python scripts/generate_assets.sh ${EXTRACTED}
@@ -28,11 +28,11 @@ if [[ -z $localization_file ]]; then
exit 1 exit 1
fi fi
echo "Generating frontend/src/assets/item_category_map.json..." echo "Generating application/src/assets/item_category_map.json..."
python scripts/item_category_map.py $items_file | python -m json.tool > frontend/src/assets/item_category_map.json python scripts/item_category_map.py $items_file | python -m json.tool > application/src/assets/item_category_map.json
echo "Generating frontend/src/assets/localization.json..." echo "Generating application/src/assets/localization.json..."
python scripts/localization.py $localization_file | python -m json.tool > frontend/src/assets/localization.json python scripts/localization.py $localization_file | python -m json.tool > application/src/assets/localization.json
echo "Generating backend/assets/item_ids.txt..." echo "Generating backend/assets/item_ids.txt..."
python scripts/item_id.py $items_file > backend/assets/item_ids.txt python scripts/item_id.py $items_file > backend/assets/item_ids.txt
+2 -2
View File
@@ -1,6 +1,6 @@
# Helper script used to generate frontend/src/assets/item_category_map.json # Helper script used to generate application/src/assets/item_category_map.json
# Args: items.xml generated by ao-id-extractor # Args: items.xml generated by ao-id-extractor
# Usage python scripts/item_category_map.py items.xml > frontend/src/assets/item_category_map.json # Usage python scripts/item_category_map.py items.xml > application/src/assets/item_category_map.json
import json import json
import re import re
+2 -2
View File
@@ -1,6 +1,6 @@
# Helper script used to generate frontend/src/assets/localization.json # Helper script used to generate application/src/assets/localization.json
# Args: localization.xml generated by ao-id-extractor # Args: localization.xml generated by ao-id-extractor
# Usage python scripts/localization.py localization.xml > frontend/src/assets/localization.json # Usage python scripts/localization.py localization.xml > application/src/assets/localization.json
import json import json
import re import re