Reduced backend resposibility to emmit game events, whole addon logic implemented in python side
@@ -7,6 +7,7 @@ damage-meter.log
|
||||
|
||||
|
||||
# Python
|
||||
.tox
|
||||
.pytest_cache
|
||||
*.spec
|
||||
env
|
||||
|
||||
@@ -8,8 +8,8 @@ jobs:
|
||||
- sudo apt-get install python3-venv
|
||||
- python3 -m venv env
|
||||
- . env/bin/activate
|
||||
- pip install -v -r frontend/requirements.txt
|
||||
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data frontend/src/assets:src/assets frontend/albion-online-stats.py
|
||||
- pip install -v -r application/requirements.txt
|
||||
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data application/src/assets:src/assets application/albion-online-stats.py
|
||||
- deactivate
|
||||
before_deploy:
|
||||
- cp dist/albion-online-stats albion-online-stats-linux
|
||||
@@ -26,8 +26,8 @@ jobs:
|
||||
script:
|
||||
- python3 -m venv env
|
||||
- . env/bin/activate
|
||||
- pip install -v -r frontend/requirements.txt
|
||||
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data frontend/src/assets:src/assets frontend/albion-online-stats.py
|
||||
- pip install -v -r application/requirements.txt
|
||||
- pyinstaller -F -w -i assets/albion-stats-icon.ico --add-data application/src/assets:src/assets application/albion-online-stats.py
|
||||
- deactivate
|
||||
before_deploy:
|
||||
- cp dist/albion-online-stats albion-online-stats-osx
|
||||
|
||||
@@ -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
|
||||
|
||||
```shell
|
||||
conda env create --file frontend/environment.yml
|
||||
conda env create --file application/environment.yml
|
||||
conda activate albion
|
||||
```
|
||||
|
||||
3. Install requirements (backend will be compiled during requirements installation)
|
||||
|
||||
```shell
|
||||
pip install -v -r frontend/requirements.txt
|
||||
pip install -v -r application/requirements.txt
|
||||
```
|
||||
|
||||
4. Run the application
|
||||
```shell
|
||||
[sudo on linux] python frontend/albion-online-stats.py
|
||||
[sudo on linux] python application/albion-online-stats.py
|
||||
```
|
||||
|
||||
## GUI testing
|
||||
- Seting TESTING variable runs frontend without backend dependency
|
||||
- Seting TESTING variable runs application without backend dependency
|
||||
|
||||
```shell
|
||||
TESTING=true python frontend/albion-online-stats.py
|
||||
TESTING=true python application/albion-online-stats.py
|
||||
```
|
||||
|
||||
# License
|
||||
|
||||
@@ -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 |
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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()]
|
||||
@@ -1,16 +1,18 @@
|
||||
from .version import latest_url
|
||||
from .version import latest_version as get_latest_version
|
||||
from .version import current_version as get_current_version
|
||||
from .styling import style
|
||||
from .engine import InitializationResult
|
||||
from .engine import initialize
|
||||
from ..engine import InitializationResult
|
||||
from ..engine import initialize
|
||||
from ..utils.config import config
|
||||
|
||||
from .main import MainWidget
|
||||
from .config import config
|
||||
from PySide2.QtWidgets import QMessageBox
|
||||
from PySide2.QtWidgets import QApplication
|
||||
from .styling import style
|
||||
from ..utils.version import current_version as get_current_version
|
||||
from ..utils.version import latest_url
|
||||
from ..utils.version import latest_version as get_latest_version
|
||||
from PySide2.QtCore import Qt
|
||||
import sys
|
||||
from PySide2.QtWidgets import QApplication
|
||||
from PySide2.QtWidgets import QMessageBox
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.abspath('__file__')))
|
||||
|
||||
@@ -1,30 +1,28 @@
|
||||
import collections
|
||||
import functools
|
||||
from ..utils import assets
|
||||
from ..utils import names
|
||||
from ..utils import async_request
|
||||
from ..utils import weapon
|
||||
|
||||
from PIL import Image, ImageQt
|
||||
from io import BytesIO
|
||||
import re
|
||||
|
||||
|
||||
from PySide2 import QtCore
|
||||
from PySide2 import QtGui
|
||||
from PySide2.QtCore import Qt
|
||||
from PySide2.QtGui import QStandardItem
|
||||
from PySide2.QtGui import QStandardItemModel
|
||||
from PySide2.QtWidgets import QApplication
|
||||
from PySide2.QtWidgets import QMessageBox
|
||||
from PySide2.QtWidgets import QComboBox
|
||||
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 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 PySide2 import QtCore
|
||||
|
||||
from . import weapon
|
||||
from . import names
|
||||
from . import assets
|
||||
from . import async_request
|
||||
from io import BytesIO
|
||||
import collections
|
||||
import functools
|
||||
import re
|
||||
|
||||
Style = collections.namedtuple('Style', 'bg')
|
||||
|
||||
@@ -17,9 +17,9 @@ from PySide2 import QtCore
|
||||
|
||||
from .dmg_list import DmgList
|
||||
from . import about
|
||||
from . import engine
|
||||
from . import assets
|
||||
from .config import config
|
||||
from .. import engine
|
||||
from ..utils import assets
|
||||
from ..utils.config import config
|
||||
|
||||
|
||||
class Mode:
|
||||
@@ -1,4 +1,4 @@
|
||||
from .config import config
|
||||
from ..utils.config import config
|
||||
|
||||
cfg = config()
|
||||
font_size = cfg['window']['font-size']
|
||||
@@ -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)
|
||||
@@ -0,0 +1,2 @@
|
||||
from . import number
|
||||
from . import config
|
||||
@@ -1,6 +1,6 @@
|
||||
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):
|
||||
return os.path.join(assets_path, file)
|
||||
@@ -1,6 +1,6 @@
|
||||
import pytest
|
||||
|
||||
from number import Number
|
||||
from src.number import Number
|
||||
|
||||
def test_number_equality():
|
||||
n = 10
|
||||
@@ -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
|
||||
@@ -30,11 +30,15 @@ test_script:
|
||||
- ps: cd backend
|
||||
- cargo test
|
||||
- ps: cd ..
|
||||
- pip install tox
|
||||
- ps: cd frontend
|
||||
- tox -e ut
|
||||
- pd: cd ..
|
||||
build_script:
|
||||
- python -m venv env
|
||||
- ps: .\env\Scripts\activate.ps1
|
||||
- pip install -v -r frontend\requirements.txt
|
||||
- pyinstaller -F -w -i assets\albion-stats-icon.ico --add-data frontend\src\assets;src\assets frontend\albion-online-stats.py
|
||||
- pip install -v -r application\requirements.txt
|
||||
- pyinstaller -F -w -i assets\albion-stats-icon.ico --add-data application\src\assets;src\assets application\albion-online-stats.py
|
||||
- ps: deactivate
|
||||
after_build:
|
||||
- ps: mv dist\albion-online-stats.exe albion-online-stats.exe
|
||||
|
||||
@@ -39,6 +39,15 @@ version = "0.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
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]]
|
||||
name = "bitflags"
|
||||
version = "0.5.0"
|
||||
@@ -127,6 +136,17 @@ dependencies = [
|
||||
"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]]
|
||||
name = "dirs"
|
||||
version = "1.0.5"
|
||||
@@ -205,9 +225,11 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
||||
name = "libaostats"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"bimap",
|
||||
"bytes",
|
||||
"chrono 0.4.10",
|
||||
"cpython",
|
||||
"derive_more",
|
||||
"fake_clock",
|
||||
"lazy_static",
|
||||
"log 0.4.8",
|
||||
@@ -301,8 +323,6 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "photon_decode"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2aecada6e930f101768a1f1659b1f9c9872cea3d479dfeae3031927f67093f1"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
]
|
||||
|
||||
@@ -8,6 +8,7 @@ build = "build.rs"
|
||||
|
||||
[lib]
|
||||
name = "libaostats"
|
||||
path = "src/lib_python.rs"
|
||||
crate-type = ["dylib"]
|
||||
|
||||
[dependencies.cpython]
|
||||
@@ -15,13 +16,15 @@ version = "0.3"
|
||||
|
||||
[dependencies]
|
||||
packet_sniffer = { path = "./lib/packet-sniffer" }
|
||||
photon_decode = "0.2"
|
||||
photon_decode = { path = "./lib/photon-decode" }
|
||||
bytes = "0.4"
|
||||
simplelog = "0.6"
|
||||
timer = "0.1"
|
||||
chrono = "0.4"
|
||||
log = { version = "0.4", features = ["std"] }
|
||||
lazy_static = "1.2"
|
||||
derive_more = "0.99"
|
||||
bimap = "0.4.0"
|
||||
|
||||
[build-dependencies]
|
||||
serde_json = "1.0"
|
||||
|
||||
@@ -69,7 +69,7 @@ fn generate_messages() -> String {
|
||||
let mut out = String::new();
|
||||
|
||||
out.push_str(r"use log::*;
|
||||
use crate::game_messages::Items;
|
||||
use crate::photon_messages::Items;
|
||||
use photon_decode::Parameters;
|
||||
use photon_decode::Value;
|
||||
|
||||
@@ -89,7 +89,7 @@ use photon_decode::Value;
|
||||
}
|
||||
|
||||
out.push_str(&format!(r###"
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct {} {{
|
||||
{}
|
||||
}}
|
||||
@@ -128,7 +128,7 @@ impl {0} {{
|
||||
"###, 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");
|
||||
for msg in &[&messages.events[..], &messages.responses[..]].concat() {
|
||||
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) {
|
||||
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();
|
||||
f.write_all(content.as_bytes()).unwrap();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
&.rs.bk
|
||||
/target
|
||||
*.so
|
||||
.vscode
|
||||
@@ -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"
|
||||
@@ -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"
|
||||
@@ -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/.
|
||||
|
||||
[](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.
|
||||
@@ -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),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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 }
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
use std::fs::File;
|
||||
use std::sync::mpsc::{channel, Receiver, Sender};
|
||||
use std::thread;
|
||||
use log::*;
|
||||
use simplelog::*;
|
||||
|
||||
use packet_sniffer::UdpPacket;
|
||||
use photon_decode::Photon;
|
||||
|
||||
use crate::game::World;
|
||||
use crate::publisher::Publisher;
|
||||
|
||||
pub use crate::publisher::Subscribers;
|
||||
|
||||
|
||||
use crate::translate::udp_packet_to_game_events;
|
||||
|
||||
|
||||
pub enum InitializationError {
|
||||
NetworkInterfaceListMissing,
|
||||
}
|
||||
|
||||
pub fn initialize(subscribers: Subscribers) -> Result<(), InitializationError> {
|
||||
initialize_logging();
|
||||
|
||||
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
|
||||
thread::spawn(move || {
|
||||
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
|
||||
|
||||
let mut photon = Photon::new();
|
||||
let mut world = World::new();
|
||||
let mut publisher = Publisher::new(subscribers);
|
||||
|
||||
packet_sniffer::receive(interfaces, tx);
|
||||
info!("Listening to network packets...");
|
||||
loop {
|
||||
if let Ok(packet) = rx.recv() {
|
||||
udp_packet_to_game_events(&mut world, &mut photon, &packet)
|
||||
.into_iter()
|
||||
.for_each(|e| {
|
||||
publisher.publish(&e);
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
return Err(InitializationError::NetworkInterfaceListMissing);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn initialize_logging() {
|
||||
CombinedLogger::init(vec![WriteLogger::new(
|
||||
LevelFilter::Info,
|
||||
Config::default(),
|
||||
File::create("damage-meter.log").unwrap(),
|
||||
)]).unwrap();
|
||||
}
|
||||
@@ -1,639 +0,0 @@
|
||||
use std::fs::File;
|
||||
use std::sync::mpsc::{channel, Receiver, Sender};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::thread;
|
||||
|
||||
use log::*;
|
||||
use simplelog::*;
|
||||
|
||||
use packet_sniffer::UdpPacket;
|
||||
|
||||
use photon_decode;
|
||||
use photon_decode::Photon;
|
||||
|
||||
use crate::game_messages;
|
||||
use crate::meter;
|
||||
pub use meter::GameStats;
|
||||
pub use meter::LastFightStats;
|
||||
pub use meter::MeterConfig;
|
||||
pub use meter::OverallStats;
|
||||
pub use meter::PlayerEvents;
|
||||
pub use meter::PlayerStatistics;
|
||||
pub use meter::PlayerStatisticsVec;
|
||||
pub use meter::ZoneStats;
|
||||
|
||||
pub use meter::StatType;
|
||||
pub use crate::game_messages::Items;
|
||||
|
||||
pub enum InitializationError {
|
||||
NetworkInterfaceListMissing,
|
||||
}
|
||||
|
||||
lazy_static! {
|
||||
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new());
|
||||
}
|
||||
|
||||
pub fn stats(meter: &meter::Meter, stat_type: StatType) -> Vec<meter::PlayerStatistics> {
|
||||
match stat_type {
|
||||
StatType::Zone => meter
|
||||
.zone_stats()
|
||||
.unwrap_or(meter::PlayerStatisticsVec::new())
|
||||
.value(),
|
||||
StatType::LastFight => meter
|
||||
.last_fight_stats()
|
||||
.unwrap_or(meter::PlayerStatisticsVec::new())
|
||||
.value(),
|
||||
StatType::Overall => meter
|
||||
.overall_stats()
|
||||
.unwrap_or(meter::PlayerStatisticsVec::new())
|
||||
.value(),
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn reset(meter: &mut meter::Meter, stat_type: StatType) {
|
||||
match stat_type {
|
||||
StatType::Zone => {
|
||||
meter.reset_zone_stats();
|
||||
}
|
||||
StatType::LastFight => {
|
||||
meter.reset_last_fight_stats();
|
||||
}
|
||||
StatType::Overall => {
|
||||
meter.reset_stats();
|
||||
}
|
||||
_ => error!("Unexpected stat to reset."),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
|
||||
CombinedLogger::init(vec![WriteLogger::new(
|
||||
LevelFilter::Info,
|
||||
Config::default(),
|
||||
File::create("damage-meter.log").unwrap(),
|
||||
)])
|
||||
.unwrap();
|
||||
|
||||
let meter = meter::Meter::new();
|
||||
|
||||
let meter = Arc::new(Mutex::new(meter));
|
||||
let cloned_meter = meter.clone();
|
||||
|
||||
if let Ok(interfaces) = packet_sniffer::network_interfaces() {
|
||||
thread::spawn(move || {
|
||||
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
|
||||
|
||||
let mut photon = Photon::new();
|
||||
|
||||
packet_sniffer::receive(interfaces, tx);
|
||||
info!("Listening to network packets...");
|
||||
loop {
|
||||
if let Ok(packet) = rx.recv() {
|
||||
if packet.destination_port != 5056 && packet.source_port != 5056 {
|
||||
continue;
|
||||
}
|
||||
if let Ok(ref mut meter) = cloned_meter.lock() {
|
||||
let game_messages = photon
|
||||
.decode(&packet.payload)
|
||||
.into_iter()
|
||||
.filter_map(game_messages::into_game_message)
|
||||
.collect();
|
||||
register_messages(meter, &game_messages);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
return Err(InitializationError::NetworkInterfaceListMissing);
|
||||
}
|
||||
|
||||
Ok(meter)
|
||||
}
|
||||
|
||||
pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_messages::Message>) {
|
||||
messages
|
||||
.iter()
|
||||
.for_each(|message| register_message(meter, &message));
|
||||
}
|
||||
|
||||
fn register_message<Events>(events: &mut Events, message: &game_messages::Message)
|
||||
where
|
||||
Events: PlayerEvents,
|
||||
{
|
||||
info!("Found message {:?}", message);
|
||||
match message {
|
||||
game_messages::Message::Leave(msg) => events.register_leave(msg.source).unwrap_or(()),
|
||||
game_messages::Message::NewCharacter(msg) => {
|
||||
events.register_player(&msg.character_name, msg.source);
|
||||
events.register_item_update(msg.source, &msg.items);
|
||||
},
|
||||
game_messages::Message::CharacterEquipmentChanged(msg) => {
|
||||
events.register_item_update(msg.source, &msg.items);
|
||||
},
|
||||
game_messages::Message::Join(msg) => {
|
||||
events.register_main_player(&msg.character_name, msg.source)
|
||||
}
|
||||
game_messages::Message::HealthUpdate(msg) => events
|
||||
.register_damage_dealt(msg.target, msg.value)
|
||||
.unwrap_or(()),
|
||||
game_messages::Message::RegenerationHealthChanged(msg) => match msg.regeneration_rate {
|
||||
Some(_) => events.register_combat_leave(msg.source).unwrap_or(()),
|
||||
None => events.register_combat_enter(msg.source).unwrap_or(()),
|
||||
},
|
||||
game_messages::Message::KnockedDown(msg) => events.register_combat_leave(msg.source).unwrap_or(()),
|
||||
game_messages::Message::UpdateFame(msg) => events
|
||||
.register_fame_gain(msg.source, msg.fame as f32 / 10000.0)
|
||||
.unwrap_or(()),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use game_messages::messages;
|
||||
use game_messages::Items;
|
||||
use game_messages::Message;
|
||||
|
||||
mod helpers {
|
||||
use super::*;
|
||||
|
||||
pub fn init_() -> meter::Meter {
|
||||
meter::Meter::new()
|
||||
}
|
||||
|
||||
pub fn sleep(time: u64) {
|
||||
use fake_clock::FakeClock;
|
||||
FakeClock::advance_time(time);
|
||||
}
|
||||
}
|
||||
|
||||
trait Testing {
|
||||
fn new(source: usize) -> Self;
|
||||
}
|
||||
|
||||
trait NamedTesting {
|
||||
fn new_named(name: &str, source: usize) -> Self;
|
||||
}
|
||||
|
||||
trait ListNamedTesting {
|
||||
fn new_list_of_named(names: &[&str], source: usize) -> Self;
|
||||
}
|
||||
|
||||
trait SwitchableTesting {
|
||||
fn enabled(source: usize) -> Self;
|
||||
fn disabled(source: usize) -> Self;
|
||||
}
|
||||
|
||||
impl NamedTesting for messages::NewCharacter {
|
||||
fn new_named(name: &str, source: usize) -> Self {
|
||||
Self {
|
||||
source: source,
|
||||
character_name: name.to_owned(),
|
||||
health: 10.0,
|
||||
max_health: 10.0,
|
||||
energy: 1.0,
|
||||
max_energy: 1.0,
|
||||
items: Items::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl NamedTesting for messages::Join {
|
||||
fn new_named(name: &str, source: usize) -> Self {
|
||||
Self {
|
||||
source: source,
|
||||
character_name: name.to_owned(),
|
||||
health: 10.0,
|
||||
max_health: 10.0,
|
||||
energy: 1.0,
|
||||
max_energy: 1.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Testing for messages::NewCharacter {
|
||||
fn new(source: usize) -> Self {
|
||||
messages::NewCharacter::new_named("CH1", source)
|
||||
}
|
||||
}
|
||||
|
||||
impl Testing for messages::Join {
|
||||
fn new(source: usize) -> Self {
|
||||
messages::Join::new_named("MAIN_CH1", source)
|
||||
}
|
||||
}
|
||||
|
||||
impl Testing for messages::Leave {
|
||||
fn new(source: usize) -> Self {
|
||||
Self { source: source }
|
||||
}
|
||||
}
|
||||
|
||||
impl Testing for messages::HealthUpdate {
|
||||
fn new(source: usize) -> Self {
|
||||
Self {
|
||||
source: 200,
|
||||
target: source,
|
||||
value: -10.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Testing for messages::UpdateFame {
|
||||
fn new(source: usize) -> Self {
|
||||
Self {
|
||||
source: source,
|
||||
fame: 1000000,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl SwitchableTesting for messages::RegenerationHealthChanged {
|
||||
fn enabled(source: usize) -> Self {
|
||||
Self {
|
||||
source: source,
|
||||
health: 10.0,
|
||||
max_health: 10.0,
|
||||
regeneration_rate: Some(1.0),
|
||||
}
|
||||
}
|
||||
|
||||
fn disabled(source: usize) -> Self {
|
||||
Self {
|
||||
source: source,
|
||||
health: 10.0,
|
||||
max_health: 10.0,
|
||||
regeneration_rate: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty_session() {
|
||||
let meter = helpers::init_();
|
||||
assert_eq!(stats(&meter, StatType::Zone).len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_player_appears() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new(1)),
|
||||
);
|
||||
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_player_stats() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new(1)),
|
||||
);
|
||||
assert_eq!(stats(&meter, StatType::Zone).len(), 1);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].player, "CH1");
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
assert_eq!(zone_stats[0].time_in_combat, 0.0);
|
||||
assert_eq!(zone_stats[0].dps, 0.0);
|
||||
assert_eq!(zone_stats[0].seconds_in_game, 0.0);
|
||||
assert_eq!(zone_stats[0].fame, 0.0);
|
||||
assert_eq!(zone_stats[0].fame_per_minute, 0);
|
||||
assert_eq!(zone_stats[0].fame_per_hour, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_damage_aggregation() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new(1)),
|
||||
);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 10.0);
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 20.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_player_damage() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new(1)),
|
||||
);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
assert_eq!(zone_stats[0].player, "CH1");
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
|
||||
);
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 10.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_player_damage_reset() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new(1)),
|
||||
);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
assert_eq!(zone_stats[0].player, "CH1");
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
|
||||
);
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 10.0);
|
||||
|
||||
reset(&mut meter, StatType::Zone);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zone_detection() {
|
||||
let mut meter = helpers::init_();
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::Join(messages::Join::new(1)),
|
||||
);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
assert_eq!(zone_stats[0].player, "MAIN_CH1");
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(1)),
|
||||
);
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 10.0);
|
||||
|
||||
register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::Join(messages::Join::new(2)),
|
||||
);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 0.0);
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(2)),
|
||||
);
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new(2)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert_eq!(zone_stats[0].damage, 10.0);
|
||||
}
|
||||
|
||||
macro_rules! main_character_enters {
|
||||
($meter:expr, $name:expr, $id:expr) => {
|
||||
register_message(
|
||||
&mut $meter,
|
||||
&Message::Join(messages::Join::new_named($name, $id)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! character_enters {
|
||||
($meter:expr, $name:expr, $id:expr) => {
|
||||
register_message(
|
||||
&mut $meter,
|
||||
&Message::NewCharacter(messages::NewCharacter::new_named($name, $id)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! attack {
|
||||
($meter:expr, $id:expr) => {
|
||||
register_message(
|
||||
&mut $meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::disabled(
|
||||
$id,
|
||||
)),
|
||||
);
|
||||
register_message(
|
||||
&mut $meter,
|
||||
&Message::HealthUpdate(messages::HealthUpdate::new($id)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! combat_leave {
|
||||
($meter:expr, $id:expr) => {
|
||||
register_message(
|
||||
&mut $meter,
|
||||
&Message::RegenerationHealthChanged(messages::RegenerationHealthChanged::enabled(
|
||||
$id,
|
||||
)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_two_players_in_the_zone() {
|
||||
let mut meter = helpers::init_();
|
||||
main_character_enters!(meter, "MAIN_CH1", 1);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
character_enters!(meter, "CH1", 2);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
register_message(&mut meter, &Message::Leave(messages::Leave::new(1)));
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
assert!(zone_stats.iter().find(|s| s.player == "CH1").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_overall_damage() {
|
||||
let mut meter = helpers::init_();
|
||||
main_character_enters!(meter, "MAIN_CH1", 1);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
attack!(meter, 1);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
character_enters!(meter, "CH1", 2);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
attack!(meter, 1);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 20.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_last_fight_damage() {
|
||||
let mut meter = helpers::init_();
|
||||
main_character_enters!(meter, "MAIN_CH1", 1);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
attack!(meter, 1);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_last_fight_management() {
|
||||
// session should be started when first player attacks
|
||||
// damage should be 0 when all players were out of combat and some player attacks
|
||||
|
||||
let mut meter = helpers::init_();
|
||||
main_character_enters!(meter, "MAIN_CH1", 1);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
attack!(meter, 1);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
character_enters!(meter, "CH1", 2);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
attack!(meter, 2);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
character_enters!(meter, "CH2", 3);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
|
||||
attack!(meter, 3);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
combat_leave!(meter, 1);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
combat_leave!(meter, 2);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
combat_leave!(meter, 3);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
|
||||
attack!(meter, 1);
|
||||
|
||||
combat_leave!(meter, 3);
|
||||
let zone_stats = stats(&meter, StatType::LastFight);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 10.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH1").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "CH2").unwrap();
|
||||
assert_eq!(player_stats.damage, 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fame_statistics() {
|
||||
let mut meter = helpers::init_();
|
||||
main_character_enters!(meter, "MAIN_CH1", 1);
|
||||
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.fame_per_minute, 0);
|
||||
|
||||
helpers::sleep(1000 * 60);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.fame_per_minute, 0);
|
||||
|
||||
register_message(
|
||||
&mut meter,
|
||||
&Message::UpdateFame(messages::UpdateFame::new(1)),
|
||||
);
|
||||
let zone_stats = stats(&meter, StatType::Zone);
|
||||
let player_stats = zone_stats.iter().find(|s| s.player == "MAIN_CH1").unwrap();
|
||||
assert_eq!(player_stats.fame_per_minute, 100);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod python;
|
||||
@@ -0,0 +1,142 @@
|
||||
use cpython::PyObject;
|
||||
use cpython::Python;
|
||||
use cpython::ToPyObject;
|
||||
use cpython::PythonObject;
|
||||
use cpython::PyDict;
|
||||
|
||||
use crate::game::Event;
|
||||
use crate::game::events;
|
||||
use crate::game::StaticId;
|
||||
use crate::photon_messages;
|
||||
|
||||
impl ToPyObject for Event {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let event = PyDict::new(py);
|
||||
|
||||
match self {
|
||||
Event::MainPlayerAppeared(e) => {
|
||||
event.set_item(py, "name", "MainPlayerAppeared".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
},
|
||||
Event::PlayerAppeared(e) => {
|
||||
event.set_item(py, "name", "PlayerAppeared".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
},
|
||||
Event::ZoneChange => {
|
||||
event.set_item(py, "name", "ZoneChange".into_py_object(py)).unwrap_or(());
|
||||
},
|
||||
Event::UpdateItems(e) => {
|
||||
event.set_item(py, "name", "UpdateItems".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
Event::DamageDone(e) => {
|
||||
event.set_item(py, "name", "DamageDone".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
Event::EnterCombat(e) => {
|
||||
event.set_item(py, "name", "EnterCombat".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
Event::LeaveCombat(e) => {
|
||||
event.set_item(py, "name", "LeaveCombat".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
Event::UpdateFame(e) => {
|
||||
event.set_item(py, "name", "UpdateFame".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
Event::HealthReceived(e) => {
|
||||
event.set_item(py, "name", "HealthReceived".into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", e.into_py_object(py)).unwrap_or(());
|
||||
}
|
||||
}
|
||||
|
||||
event.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for StaticId {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
self.inner().into_py_object(py).into_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl ToPyObject for events::Player {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let event = PyDict::new(py);
|
||||
|
||||
event.set_item(py, "id", self.id.into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "name", self.name.clone().into_py_object(py)).unwrap_or(());
|
||||
event.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for events::Damage {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let event = PyDict::new(py);
|
||||
|
||||
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "target", self.target.into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
|
||||
event.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for events::Fame {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let event = PyDict::new(py);
|
||||
|
||||
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", self.value.into_py_object(py).into_object()).unwrap_or(());
|
||||
event.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for events::Items {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let event = PyDict::new(py);
|
||||
|
||||
event.set_item(py, "source", self.source.into_py_object(py)).unwrap_or(());
|
||||
event.set_item(py, "value", self.value.clone().into_py_object(py)).unwrap_or(());
|
||||
event.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! set_dict_item {
|
||||
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
|
||||
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
|
||||
{}
|
||||
};
|
||||
}
|
||||
|
||||
impl ToPyObject for photon_messages::Items {
|
||||
type ObjectType = PyDict;
|
||||
|
||||
fn into_py_object(self, py: Python) -> Self::ObjectType {
|
||||
self.to_py_object(py)
|
||||
}
|
||||
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let items = PyDict::new(py);
|
||||
|
||||
set_dict_item!(py, items, self, weapon);
|
||||
set_dict_item!(py, items, self, offhand);
|
||||
set_dict_item!(py, items, self, helmet);
|
||||
set_dict_item!(py, items, self, armor);
|
||||
set_dict_item!(py, items, self, boots);
|
||||
set_dict_item!(py, items, self, bag);
|
||||
set_dict_item!(py, items, self, cape);
|
||||
set_dict_item!(py, items, self, mount);
|
||||
set_dict_item!(py, items, self, potion);
|
||||
set_dict_item!(py, items, self, food);
|
||||
|
||||
items
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod convert;
|
||||
@@ -0,0 +1,133 @@
|
||||
use std::convert::From;
|
||||
|
||||
use crate::photon_messages::messages;
|
||||
|
||||
use super::events;
|
||||
use super::player::{StaticId, PlayerName};
|
||||
|
||||
pub struct EventIntermediate<Msg> {
|
||||
id: StaticId,
|
||||
name: PlayerName,
|
||||
message: Msg,
|
||||
}
|
||||
|
||||
impl<Msg> EventIntermediate<Msg> {
|
||||
pub fn new(
|
||||
id: StaticId,
|
||||
name: PlayerName,
|
||||
message: Msg,
|
||||
) -> Self {
|
||||
Self {
|
||||
id,
|
||||
name,
|
||||
message,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct EventList {
|
||||
value: Vec<events::Event>,
|
||||
}
|
||||
|
||||
impl EventList {
|
||||
pub fn new(list: Vec<events::Event>) -> Self {
|
||||
Self { value: list }
|
||||
}
|
||||
|
||||
pub fn values(self) -> Vec<events::Event> {
|
||||
self.value
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::NewCharacter>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
|
||||
Self::PlayerAppeared(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.message.character_name,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::NewCharacter>> for EventList {
|
||||
fn from(intermediate: EventIntermediate<messages::NewCharacter>) -> Self {
|
||||
Self::new(vec![
|
||||
events::Event::PlayerAppeared(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.message.character_name,
|
||||
}),
|
||||
events::Event::UpdateItems(events::Items {
|
||||
source: intermediate.id,
|
||||
value: intermediate.message.items,
|
||||
}),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::Join>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::Join>) -> Self {
|
||||
Self::MainPlayerAppeared(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.message.character_name,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::HealthUpdate>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::HealthUpdate>) -> Self {
|
||||
if intermediate.message.value < 0.0 {
|
||||
return Self::DamageDone(events::Damage {
|
||||
source: intermediate.id,
|
||||
target: None,
|
||||
value: f32::abs(intermediate.message.value),
|
||||
});
|
||||
}
|
||||
Self::HealthReceived(events::Damage {
|
||||
source: intermediate.id,
|
||||
target: None,
|
||||
value: intermediate.message.value,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl From<EventIntermediate<messages::RegenerationHealthChanged>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::RegenerationHealthChanged>) -> Self {
|
||||
match intermediate.message.regeneration_rate {
|
||||
Some(_) => Self::LeaveCombat(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.name.into(),
|
||||
}),
|
||||
None => Self::EnterCombat(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.name.into(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::KnockedDown>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::KnockedDown>) -> Self {
|
||||
Self::LeaveCombat(events::Player {
|
||||
id: intermediate.id,
|
||||
name: intermediate.name.into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::UpdateFame>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::UpdateFame>) -> Self {
|
||||
Self::UpdateFame(events::Fame {
|
||||
source: intermediate.id,
|
||||
value: intermediate.message.fame as f32 / 10000.0,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<EventIntermediate<messages::CharacterEquipmentChanged>> for events::Event {
|
||||
fn from(intermediate: EventIntermediate<messages::CharacterEquipmentChanged>) -> Self {
|
||||
Self::UpdateItems(events::Items {
|
||||
source: intermediate.id,
|
||||
value: intermediate.message.items,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#![allow(dead_code)]
|
||||
|
||||
use crate::photon_messages;
|
||||
|
||||
use super::player::StaticId;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Player {
|
||||
pub id: StaticId,
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Damage {
|
||||
pub source: StaticId,
|
||||
pub target: Option<StaticId>,
|
||||
pub value: f32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Fame {
|
||||
pub source: StaticId,
|
||||
pub value: f32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Items {
|
||||
pub source: StaticId,
|
||||
pub value: photon_messages::Items,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Event {
|
||||
MainPlayerAppeared(Player),
|
||||
PlayerAppeared(Player),
|
||||
DamageDone(Damage),
|
||||
HealthReceived(Damage),
|
||||
ZoneChange,
|
||||
EnterCombat(Player),
|
||||
LeaveCombat(Player),
|
||||
UpdateFame(Fame),
|
||||
UpdateItems(Items),
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
#![allow(dead_code)]
|
||||
|
||||
use bimap::BiMap;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use super::player::{StaticId, DynamicId, PlayerName};
|
||||
|
||||
#[derive(Debug, PartialEq, Default)]
|
||||
pub struct IdCache {
|
||||
name_to_static_id: HashMap<String, u32>,
|
||||
dyn_id_to_name: BiMap<u32, String>,
|
||||
last_id: u32,
|
||||
}
|
||||
|
||||
impl IdCache {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save(&mut self, dynamic_id: DynamicId, name: &str) {
|
||||
if self.name_to_static_id.get(name).is_none() {
|
||||
let id = self.last_id;
|
||||
self.last_id += 1;
|
||||
self.name_to_static_id.insert(name.to_owned(), id);
|
||||
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
|
||||
}
|
||||
|
||||
self.dyn_id_to_name.insert(dynamic_id.into(), name.to_owned());
|
||||
}
|
||||
|
||||
pub fn get_static_id(&self, dynamic_id: DynamicId) -> Option<StaticId> {
|
||||
self.dyn_id_to_name
|
||||
.get_by_left(&dynamic_id.into())
|
||||
.map(|name| {
|
||||
self.name_to_static_id
|
||||
.get(name)
|
||||
.map(|v| *v)
|
||||
.map(|v| v.into())
|
||||
})
|
||||
.flatten()
|
||||
}
|
||||
|
||||
pub fn get_name(&self, static_id: StaticId) -> Option<PlayerName> {
|
||||
self.name_to_static_id
|
||||
.iter()
|
||||
.find(|(_k, v)| **v == StaticId::into(static_id))
|
||||
.map(|v| v.0)
|
||||
.map(|v| v.clone().into())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_id_cache() {
|
||||
let mut cache = IdCache::new();
|
||||
|
||||
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
|
||||
|
||||
cache.save(DynamicId::from(1), "test");
|
||||
assert!(cache.get_static_id(DynamicId::from(1)).is_some());
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
|
||||
|
||||
cache.save(DynamicId::from(2), "test");
|
||||
assert!(cache.get_static_id(DynamicId::from(1)).is_none());
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_if_id_is_unique_for_a_player() {
|
||||
let mut cache = IdCache::new();
|
||||
|
||||
cache.save(DynamicId::from(1), "test");
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
|
||||
|
||||
cache.save(DynamicId::from(2), "test2");
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
|
||||
|
||||
cache.save(DynamicId::from(12345), "test3");
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(12345)), Some(StaticId::from(2)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_finding_player_name() {
|
||||
let mut cache = IdCache::new();
|
||||
|
||||
assert!(cache.get_name(StaticId::from(1)).is_none());
|
||||
|
||||
cache.save(DynamicId::from(1), "test");
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(1)), Some(StaticId::from(0)));
|
||||
assert_eq!(
|
||||
cache.get_name(StaticId::from(0)),
|
||||
Some(PlayerName::from("test".to_owned()))
|
||||
);
|
||||
|
||||
cache.save(DynamicId::from(2), "test2");
|
||||
assert_eq!(cache.get_static_id(DynamicId::from(2)), Some(StaticId::from(1)));
|
||||
assert_eq!(
|
||||
cache.get_name(StaticId::from(1)),
|
||||
Some(PlayerName::from("test2".to_owned()))
|
||||
);
|
||||
assert_eq!(
|
||||
cache.get_name(StaticId::from(0)),
|
||||
Some(PlayerName::from("test".to_owned()))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
pub mod events;
|
||||
pub mod convert;
|
||||
pub mod world;
|
||||
pub mod id_cache;
|
||||
|
||||
mod unconsumed_messages;
|
||||
mod player;
|
||||
|
||||
pub use player::StaticId;
|
||||
pub use events::*;
|
||||
pub use world::World;
|
||||
@@ -0,0 +1,16 @@
|
||||
use derive_more::{From, Into};
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq, From, Into, Default)]
|
||||
pub struct DynamicId(u32);
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq, From, Into)]
|
||||
pub struct StaticId(u32);
|
||||
|
||||
#[derive(Debug, PartialEq, From, Into, Default)]
|
||||
pub struct PlayerName(String);
|
||||
|
||||
impl StaticId {
|
||||
pub fn inner(&self) -> u32 {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
use super::player::{DynamicId};
|
||||
use crate::photon_messages::Message;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Debug, PartialEq, Default)]
|
||||
pub struct UnconsumedMessages{
|
||||
messages: HashMap<u32, Vec<Message>>
|
||||
}
|
||||
|
||||
impl UnconsumedMessages {
|
||||
pub fn add(&mut self, msg: Message, id: DynamicId) {
|
||||
self.messages.entry(id.into()).or_insert(vec![]).push(msg);
|
||||
}
|
||||
|
||||
pub fn get_for_id(&mut self, id: DynamicId) -> Option<Vec<Message>> {
|
||||
let messages = self.messages.get(&id.into())?;
|
||||
let result = messages.clone();
|
||||
self.messages.remove(&id.into());
|
||||
|
||||
return Some(result);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,333 @@
|
||||
//! Holds state of the game gathered from photon decoded packets.
|
||||
//! Note: This module is responsible for resolving all inconsistency between photon events and required game events.
|
||||
//!
|
||||
//! Inconsistency list:
|
||||
//! - player id is different in each zone
|
||||
|
||||
use crate::photon_messages;
|
||||
|
||||
use super::events;
|
||||
use super::convert;
|
||||
use super::convert::EventList;
|
||||
use super::id_cache;
|
||||
use super::player::{StaticId, DynamicId};
|
||||
use super::unconsumed_messages::UnconsumedMessages;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
pub struct World {
|
||||
cache: id_cache::IdCache,
|
||||
unconsumed_messages: UnconsumedMessages,
|
||||
main_player_id: Option<StaticId>,
|
||||
}
|
||||
|
||||
impl World {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Transforms inconsistent game message into corresponding list of game events
|
||||
pub fn transform(
|
||||
&mut self,
|
||||
message: photon_messages::Message,
|
||||
) -> Option<Vec<events::Event>> {
|
||||
match message {
|
||||
photon_messages::Message::NewCharacter(msg) => {
|
||||
let mut result = vec![];
|
||||
let dynamic_id = DynamicId::from(msg.source as u32);
|
||||
self.assign_dynamic_id(dynamic_id, &msg.character_name);
|
||||
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
|
||||
result.append(&mut EventList::from(self.get_intermediate(static_id, msg)?).values());
|
||||
|
||||
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
|
||||
for message in messages {
|
||||
result.append(&mut self.transform(message).unwrap_or(vec![]));
|
||||
}
|
||||
}
|
||||
|
||||
Some(result)
|
||||
}
|
||||
photon_messages::Message::Join(msg) => {
|
||||
let mut result = vec![];
|
||||
let dynamic_id = DynamicId::from(msg.source as u32);
|
||||
|
||||
self.assign_dynamic_id(dynamic_id, &msg.character_name);
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
|
||||
if self.main_player_id.is_none() {
|
||||
result.push(events::Event::ZoneChange)
|
||||
}
|
||||
|
||||
result.push(self.get_intermediate(static_id, msg)?.into());
|
||||
|
||||
|
||||
self.main_player_id = Some(static_id);
|
||||
|
||||
if let Some(messages) = self.unconsumed_messages.get_for_id(dynamic_id) {
|
||||
for message in messages {
|
||||
result.append(&mut self.transform(message).unwrap_or(vec![]));
|
||||
}
|
||||
}
|
||||
|
||||
Some(result)
|
||||
}
|
||||
photon_messages::Message::Leave(msg) => {
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
if let Some(main_player_id) = self.main_player_id {
|
||||
if main_player_id == static_id {
|
||||
return Some(vec![events::Event::ZoneChange]);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
photon_messages::Message::HealthUpdate(msg) => {
|
||||
let static_id = self.get_static_id(msg.target)?;
|
||||
Some(vec![self.get_intermediate(static_id, msg)?.into()])
|
||||
}
|
||||
photon_messages::Message::RegenerationHealthChanged(msg) => {
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
Some(vec![self.get_intermediate(static_id, msg)?.into()])
|
||||
}
|
||||
photon_messages::Message::KnockedDown(msg) => {
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
Some(vec![self.get_intermediate(static_id, msg)?.into()])
|
||||
}
|
||||
photon_messages::Message::UpdateFame(msg) => {
|
||||
let static_id = self.get_static_id(msg.source)?;
|
||||
Some(vec![self.get_intermediate(static_id, msg)?.into()])
|
||||
}
|
||||
photon_messages::Message::CharacterEquipmentChanged(msg) => {
|
||||
if let Some(static_id) = self.get_static_id(msg.source) {
|
||||
return Some(vec![self.get_intermediate(static_id, msg)?.into()]);
|
||||
}
|
||||
let id = DynamicId::from(msg.source as u32);
|
||||
self.unconsumed_messages.add(
|
||||
photon_messages::messages::Message::CharacterEquipmentChanged(msg), id);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
fn assign_dynamic_id(&mut self, id: DynamicId, name: &str) {
|
||||
self.cache.save(id, name);
|
||||
}
|
||||
|
||||
fn get_static_id(&self, id: usize) -> Option<StaticId> {
|
||||
let dynamic_id = DynamicId::from(id as u32);
|
||||
self.cache.get_static_id(dynamic_id) // queue message if static id isn't known
|
||||
}
|
||||
|
||||
fn get_intermediate<Msg>(
|
||||
&self,
|
||||
static_id: StaticId,
|
||||
msg: Msg,
|
||||
) -> Option<convert::EventIntermediate<Msg>> {
|
||||
Some(convert::EventIntermediate::new(
|
||||
static_id,
|
||||
self.cache.get_name(static_id)?,
|
||||
msg,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
macro_rules! assert_contains {
|
||||
($container:expr, $value:expr) => {
|
||||
assert!(
|
||||
format!("{:?}", $container).contains($value),
|
||||
format!("{:?} does not contains {}", $container, $value)
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! simulate_new_player {
|
||||
($id:expr, $name:expr, $msg:ident) => {
|
||||
photon_messages::Message::$msg(photon_messages::messages::$msg {
|
||||
source: $id,
|
||||
character_name: $name.to_string(),
|
||||
..Default::default()
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::NewCharacter -> events::Event::PlayerAppeared
|
||||
fn test_player_appeared() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", NewCharacter);
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(
|
||||
world.transform(game_message.clone()),
|
||||
"PlayerAppeared"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::Join -> Event::PlayerAppeared
|
||||
fn test_main_player_appeared() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(
|
||||
world.transform(game_message.clone()),
|
||||
"PlayerAppeared"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::HealthUpdate -> Event::DamageDone | Event::HealthReceived
|
||||
fn test_damage_done() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(
|
||||
world.transform(game_message.clone()),
|
||||
"PlayerAppeared"
|
||||
);
|
||||
|
||||
let target = 1;
|
||||
let game_message =
|
||||
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
|
||||
target,
|
||||
value: -666.0,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(world.transform(game_message.clone()), "DamageDone");
|
||||
assert_contains!(world.transform(game_message.clone()), "-666");
|
||||
|
||||
let target = 1;
|
||||
let game_message =
|
||||
photon_messages::Message::HealthUpdate(photon_messages::messages::HealthUpdate {
|
||||
target,
|
||||
value: 666.0,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(
|
||||
world.transform(game_message.clone()),
|
||||
"HealthReceived"
|
||||
);
|
||||
assert_contains!(world.transform(game_message.clone()), "666");
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::Leave -> Event::ZoneChange
|
||||
fn test_zone_change() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
|
||||
source: 1,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_none());
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
assert_contains!(
|
||||
world.transform(game_message.clone()),
|
||||
"PlayerAppeared"
|
||||
);
|
||||
|
||||
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
|
||||
source: 1,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert_contains!(world.transform(game_message.clone()), "ZoneChange");
|
||||
|
||||
let game_message = simulate_new_player!(2, "TestCharacter", NewCharacter);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
let game_message = photon_messages::Message::Leave(photon_messages::messages::Leave {
|
||||
source: 1,
|
||||
..Default::default()
|
||||
});
|
||||
assert!(world.transform(game_message.clone()).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::LeaveCombat
|
||||
fn test_combat_leave_via_regeneration_change() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
|
||||
let game_message = photon_messages::Message::RegenerationHealthChanged(
|
||||
photon_messages::messages::RegenerationHealthChanged {
|
||||
source: 1,
|
||||
regeneration_rate: Some(1.0),
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::RegenerationHealthChanged.regeneration_rate -> Event::EnterCombat
|
||||
fn test_combat_enter_via_regeneration_change() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
|
||||
let game_message = photon_messages::Message::RegenerationHealthChanged(
|
||||
photon_messages::messages::RegenerationHealthChanged {
|
||||
source: 1,
|
||||
regeneration_rate: None,
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
assert_contains!(world.transform(game_message.clone()), "EnterCombat");
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::KnockedDown -> Event::EnterCombat
|
||||
fn test_combat_enter_via_knockout() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
|
||||
let game_message =
|
||||
photon_messages::Message::KnockedDown(photon_messages::messages::KnockedDown {
|
||||
source: 1,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert_contains!(world.transform(game_message.clone()), "LeaveCombat");
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// photon_messages::UpdateFame -> Event::FameUpdate
|
||||
fn test_fame_update() {
|
||||
let mut world = World::new();
|
||||
|
||||
let game_message = simulate_new_player!(1, "TestCharacter", Join);
|
||||
assert!(world.transform(game_message.clone()).is_some());
|
||||
|
||||
let game_message =
|
||||
photon_messages::Message::UpdateFame(photon_messages::messages::UpdateFame {
|
||||
source: 1,
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
assert_contains!(world.transform(game_message.clone()), "UpdateFame");
|
||||
}
|
||||
}
|
||||
@@ -1,200 +0,0 @@
|
||||
#[macro_use]
|
||||
extern crate cpython;
|
||||
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
|
||||
pub mod game_messages;
|
||||
mod meter;
|
||||
|
||||
mod core;
|
||||
|
||||
use std::sync::{Mutex, Arc};
|
||||
use log::*;
|
||||
|
||||
use cpython::PyList;
|
||||
use cpython::PyObject;
|
||||
use cpython::PyResult;
|
||||
use cpython::Python;
|
||||
use cpython::ToPyObject;
|
||||
use cpython::PythonObject;
|
||||
use cpython::FromPyObject;
|
||||
use cpython::PyDict;
|
||||
|
||||
use crate::core::StatType;
|
||||
use crate::core::InitializationError;
|
||||
|
||||
|
||||
struct PyMeter
|
||||
{
|
||||
value: Option<Arc<Mutex<meter::Meter>>>
|
||||
}
|
||||
|
||||
impl PyMeter
|
||||
{
|
||||
fn new() -> Self {
|
||||
Self{value: None}
|
||||
}
|
||||
|
||||
fn initialize(&mut self, value: Arc<Mutex<meter::Meter>>) {
|
||||
self.value = Some(value);
|
||||
}
|
||||
|
||||
fn get(&mut self) -> Option<Arc<Mutex<meter::Meter>>> {
|
||||
self.value.clone()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
lazy_static! {
|
||||
static ref METER: Mutex<PyMeter> = Mutex::new(PyMeter::new());
|
||||
}
|
||||
|
||||
macro_rules! set_dict_item {
|
||||
($py:ident, $dict:ident, $from:ident, $field_name:ident) => {
|
||||
if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py))
|
||||
{}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
impl ToPyObject for core::PlayerStatistics {
|
||||
type ObjectType = PyObject;
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let stats = PyDict::new(py);
|
||||
|
||||
set_dict_item!(py, stats, self, player);
|
||||
set_dict_item!(py, stats, self, damage);
|
||||
set_dict_item!(py, stats, self, time_in_combat);
|
||||
set_dict_item!(py, stats, self, dps);
|
||||
set_dict_item!(py, stats, self, seconds_in_game);
|
||||
set_dict_item!(py, stats, self, fame);
|
||||
set_dict_item!(py, stats, self, fame_per_minute);
|
||||
set_dict_item!(py, stats, self, fame_per_hour);
|
||||
set_dict_item!(py, stats, self, items);
|
||||
|
||||
stats.into_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for core::PlayerStatisticsVec {
|
||||
type ObjectType = PyList;
|
||||
|
||||
fn into_py_object(self, py: Python) -> Self::ObjectType {
|
||||
self.value().into_py_object(py)
|
||||
}
|
||||
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
self.value().into_py_object(py)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToPyObject for core::Items {
|
||||
type ObjectType = PyDict;
|
||||
|
||||
fn into_py_object(self, py: Python) -> Self::ObjectType {
|
||||
self.to_py_object(py)
|
||||
}
|
||||
|
||||
fn to_py_object(&self, py: Python) -> Self::ObjectType {
|
||||
let items = PyDict::new(py);
|
||||
|
||||
set_dict_item!(py, items, self, weapon);
|
||||
set_dict_item!(py, items, self, offhand);
|
||||
set_dict_item!(py, items, self, helmet);
|
||||
set_dict_item!(py, items, self, armor);
|
||||
set_dict_item!(py, items, self, boots);
|
||||
set_dict_item!(py, items, self, bag);
|
||||
set_dict_item!(py, items, self, cape);
|
||||
set_dict_item!(py, items, self, mount);
|
||||
set_dict_item!(py, items, self, potion);
|
||||
set_dict_item!(py, items, self, food);
|
||||
|
||||
items
|
||||
}
|
||||
}
|
||||
|
||||
impl <'source> FromPyObject<'source> for StatType {
|
||||
fn extract(py: Python, obj: &'source PyObject) -> PyResult<Self> {
|
||||
match obj.extract(py) {
|
||||
Ok(n) => {
|
||||
match n {
|
||||
1 => Ok(StatType::LastFight),
|
||||
2 => Ok(StatType::Zone),
|
||||
3 => Ok(StatType::Overall),
|
||||
_ => Ok(StatType::Unknown)
|
||||
}
|
||||
},
|
||||
Err(e) => Err(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub fn stats(py: Python, stat_type: StatType) -> PyResult<PyDict> {
|
||||
let stats = PyDict::new(py);
|
||||
if let Ok(ref mut py_meter) = METER.lock() {
|
||||
if let Some(m) = py_meter.get() {
|
||||
if let Ok(ref mut meter) = m.lock() {
|
||||
let mut main : Option<core::PlayerStatistics> = None;
|
||||
stats.set_item(py, "players", core::stats(&meter, stat_type)
|
||||
.into_iter()
|
||||
.inspect(|s| {
|
||||
if s.main_player_stats {
|
||||
main = Some(s.clone());
|
||||
}
|
||||
})
|
||||
.filter(|s| !s.idle || s.fame != 0.0)
|
||||
.collect::<Vec<meter::PlayerStatistics>>()
|
||||
.into_py_object(py)).ok();
|
||||
stats.set_item(py, "main", main.into_py_object(py)).ok();
|
||||
return Ok(stats);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
error!("Failed to acquire locks on meter");
|
||||
Ok(stats)
|
||||
}
|
||||
|
||||
pub fn reset(_py: Python, stat_type: StatType) -> PyResult<u32> {
|
||||
if let Ok(ref mut py_meter) = METER.lock() {
|
||||
if let Some(m) = py_meter.get() {
|
||||
if let Ok(ref mut meter) = m.lock() {
|
||||
core::reset(meter, stat_type);
|
||||
return Ok(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
error!("Failed to acquire locks on meter");
|
||||
Ok(1)
|
||||
}
|
||||
|
||||
fn initialize(_py: Python) -> PyResult<u32> {
|
||||
if let Ok(ref mut py_meter) = METER.lock() {
|
||||
match core::initialize() {
|
||||
Ok(core_meter) => py_meter.initialize(core_meter),
|
||||
Err(InitializationError::NetworkInterfaceListMissing) => return Ok(2)
|
||||
};
|
||||
|
||||
if let Some(m) = py_meter.get() {
|
||||
if let Ok(ref mut meter) = m.lock() {
|
||||
meter.configure(core::MeterConfig {
|
||||
..Default::default()
|
||||
});
|
||||
return Ok(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
error!("Failed to initialize meter");
|
||||
Ok(1)
|
||||
}
|
||||
|
||||
py_module_initializer!(libaostats, initlibaostats, PyInit_libaostats, |py, m| {
|
||||
m.add(py, "__doc__", "This module is implemented in Rust")?;
|
||||
m.add(py, "initialize", py_fn!(py, initialize()))?;
|
||||
m.add(py, "stats", py_fn!(py, stats(stat_type: StatType)))?;
|
||||
m.add(py, "reset", py_fn!(py, reset(stat_type: StatType)))?;
|
||||
Ok(())
|
||||
});
|
||||
@@ -0,0 +1,64 @@
|
||||
#[macro_use]
|
||||
extern crate cpython;
|
||||
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
|
||||
mod photon_messages;
|
||||
mod game;
|
||||
mod translate;
|
||||
mod publisher;
|
||||
mod crosslang;
|
||||
mod api;
|
||||
|
||||
use std::sync::Mutex;
|
||||
use log::*;
|
||||
|
||||
use cpython::PyResult;
|
||||
use cpython::Python;
|
||||
use cpython::ToPyObject;
|
||||
use cpython::PythonObject;
|
||||
use cpython::ObjectProtocol;
|
||||
use cpython::PyTuple;
|
||||
|
||||
lazy_static! {
|
||||
static ref PY_CALLBACKS: Mutex<Vec<cpython::PyObject>> = Mutex::new(Vec::new());
|
||||
}
|
||||
|
||||
fn python_callbacks_subscriber(event: game::Event) {
|
||||
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
|
||||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
|
||||
for py_callback in py_callbacks.iter() {
|
||||
let py_args = [event.clone().into_py_object(py).into_object()];
|
||||
let args = PyTuple::new(py, &py_args[..]);
|
||||
|
||||
if let Some(error) = py_callback.call(py, args, None).err() {
|
||||
error!("{:?}", error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn initialize(_py: Python) -> PyResult<u32> {
|
||||
api::initialize(vec![
|
||||
Box::new(python_callbacks_subscriber)
|
||||
]).map_or(Ok(0), |_| {Ok(2)})
|
||||
}
|
||||
|
||||
fn subscribe(_py: Python, callable: cpython::PyObject) -> PyResult<u32> {
|
||||
if let Ok(ref mut py_callbacks) = &mut PY_CALLBACKS.lock() {
|
||||
py_callbacks.push(callable);
|
||||
}
|
||||
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
|
||||
py_module_initializer!(libaostats, initlibaostats, PyInit_libaostats, |py, m| {
|
||||
m.add(py, "__doc__", "This module is implemented in Rust")?;
|
||||
m.add(py, "initialize", py_fn!(py, initialize()))?;
|
||||
m.add(py, "subscribe", py_fn!(py, subscribe(callable: cpython::PyObject)))?;
|
||||
Ok(())
|
||||
});
|
||||
@@ -10,9 +10,10 @@ mod traits;
|
||||
mod types;
|
||||
mod session;
|
||||
|
||||
use crate::game::Event;
|
||||
use player::Player;
|
||||
|
||||
pub use super::game_messages;
|
||||
use super::photon_messages;
|
||||
pub use traits::*;
|
||||
pub use types::*;
|
||||
|
||||
@@ -21,29 +22,138 @@ use session::Session;
|
||||
#[derive(Default)]
|
||||
pub struct MeterConfig {}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Meter {
|
||||
zone_history: PlayerStatisticsVec,
|
||||
zone_session: Option<Session>,
|
||||
last_fight_session: Session,
|
||||
main_player_id: Option<usize>,
|
||||
unconsumed_items: HashMap<usize, game_messages::Items>,
|
||||
config: MeterConfig,
|
||||
unconsumed_items: HashMap<usize, photon_messages::Items>,
|
||||
}
|
||||
|
||||
impl Meter {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
zone_history: PlayerStatisticsVec::new(),
|
||||
zone_session: None,
|
||||
last_fight_session: Session::new(),
|
||||
main_player_id: None,
|
||||
unconsumed_items: HashMap::new(),
|
||||
config: Default::default(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn configure(&mut self, config: MeterConfig) {
|
||||
self.config = config;
|
||||
pub fn consume(&mut self, event: Event) -> Option<()> {
|
||||
match event {
|
||||
Event::MainPlayerAppeared(e) => {
|
||||
let id = u32::from(e.id) as usize;
|
||||
self.register_player(&e.name, id, true);
|
||||
|
||||
if let Some(items) = self.unconsumed_items.get(&id) {
|
||||
let i = items.clone();
|
||||
self.register_item_update(id, &i);
|
||||
self.unconsumed_items.remove(&id);
|
||||
}
|
||||
},
|
||||
Event::PlayerAppeared(e) => {
|
||||
let id = u32::from(e.id) as usize;
|
||||
self.register_player(&e.name, id, false);
|
||||
|
||||
if let Some(items) = self.unconsumed_items.get(&id) {
|
||||
let i = items.clone();
|
||||
self.register_item_update(id, &i);
|
||||
self.unconsumed_items.remove(&id);
|
||||
}
|
||||
},
|
||||
Event::ZoneChange => {
|
||||
self.new_session();
|
||||
},
|
||||
Event::UpdateItems(e) => {
|
||||
let player_id = u32::from(e.source) as usize;
|
||||
let items = e.value;
|
||||
let mut consumed = false;
|
||||
for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) {
|
||||
player.items_update(&items);
|
||||
consumed = true;
|
||||
}
|
||||
|
||||
if !consumed {
|
||||
info!("Storing not consumed items for player id: {}", player_id);
|
||||
self.unconsumed_items.insert(player_id, items.clone());
|
||||
}
|
||||
}
|
||||
Event::DamageDone(e) => {
|
||||
let player_id = u32::from(e.source) as usize;
|
||||
for player in self.get_players_in_the_zone(player_id)? {
|
||||
player.register_damage_dealt(f32::abs(e.value));
|
||||
}
|
||||
}
|
||||
Event::EnterCombat(e) => {
|
||||
let player_id = u32::from(e.id) as usize;
|
||||
if self.combat_state() == CombatState::OutOfCombat {
|
||||
self.last_fight_session = Session::from(&self.last_fight_session);
|
||||
}
|
||||
for player in self.get_players_in_the_zone(player_id)? {
|
||||
player.enter_combat();
|
||||
}
|
||||
}
|
||||
Event::LeaveCombat(e) => {
|
||||
let player_id = u32::from(e.id) as usize;
|
||||
for player in self.get_players_in_the_zone(player_id)? {
|
||||
player.leave_combat();
|
||||
}
|
||||
}
|
||||
Event::UpdateFame(e) => {
|
||||
let player_id = u32::from(e.source) as usize;
|
||||
for player in self.get_players_in_the_zone(player_id)? {
|
||||
player.register_fame_gain(e.value);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn get_players_in_the_zone(
|
||||
&mut self,
|
||||
player_id: usize,
|
||||
) -> Option<Vec<&mut Player>> {
|
||||
let (zone, last_fight) = self.sessions_mut()?;
|
||||
let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
|
||||
let zone_player = zone.get_player_by_id(player_id)?;
|
||||
Some(vec![zone_player, las_fight_session_player])
|
||||
}
|
||||
|
||||
fn register_player(&mut self, name: &str, id: usize, main: bool) {
|
||||
if self.zone_session.is_none() {
|
||||
info!(
|
||||
"New player ({}) registered without session, creating new session",
|
||||
name
|
||||
);
|
||||
self.new_session();
|
||||
}
|
||||
|
||||
if self
|
||||
.get_players_in_the_zone(id)
|
||||
.unwrap_or(vec![])
|
||||
.is_empty()
|
||||
{
|
||||
self.add_player(name, id, main);
|
||||
}
|
||||
}
|
||||
|
||||
fn register_item_update(
|
||||
&mut self,
|
||||
player_id: usize,
|
||||
items: &photon_messages::Items,
|
||||
) -> Option<()> {
|
||||
let mut consumed = false;
|
||||
for player in self.get_players_in_the_zone(player_id).unwrap_or(vec![]) {
|
||||
player.items_update(items);
|
||||
consumed = true;
|
||||
}
|
||||
|
||||
if !consumed {
|
||||
info!("Storing not consumed items for player id: {}", player_id);
|
||||
self.unconsumed_items.insert(player_id, items.clone());
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn stats_filter(&self, _player: &(&String, &Player)) -> bool {
|
||||
@@ -90,7 +200,6 @@ impl Meter {
|
||||
self.last_fight_session = Session::new();
|
||||
}
|
||||
|
||||
#[allow(unused)]
|
||||
fn combat_state(&self) -> CombatState {
|
||||
if self
|
||||
.last_fight_session
|
||||
@@ -105,117 +214,6 @@ impl Meter {
|
||||
}
|
||||
}
|
||||
|
||||
impl PlayerEvents for Meter {
|
||||
fn get_damage_dealers_in_zone(
|
||||
&mut self,
|
||||
player_id: usize,
|
||||
) -> Option<Vec<&mut dyn DamageDealer>> {
|
||||
let (zone, last_fight) = self.sessions_mut()?;
|
||||
let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
|
||||
let zone_player = zone.get_player_by_id(player_id)?;
|
||||
Some(vec![zone_player, las_fight_session_player])
|
||||
}
|
||||
|
||||
fn get_item_carriers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn ItemCarrier>> {
|
||||
let (zone, last_fight) = self.sessions_mut()?;
|
||||
let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
|
||||
let zone_player = zone.get_player_by_id(player_id)?;
|
||||
Some(vec![zone_player, las_fight_session_player])
|
||||
}
|
||||
|
||||
fn get_fame_gatherers_in_zone(
|
||||
&mut self,
|
||||
player_id: usize,
|
||||
) -> Option<Vec<&mut dyn FameGatherer>> {
|
||||
let main_player_id = self.main_player_id?;
|
||||
let (zone, last_fight) = self.sessions_mut()?;
|
||||
if player_id != main_player_id {
|
||||
return None;
|
||||
}
|
||||
|
||||
let las_fight_session_player = last_fight.get_player_by_id(player_id)?;
|
||||
let zone_player = zone.get_player_by_id(player_id)?;
|
||||
Some(vec![zone_player, las_fight_session_player])
|
||||
}
|
||||
|
||||
fn register_item_update(
|
||||
&mut self,
|
||||
player_id: usize,
|
||||
items: &game_messages::Items,
|
||||
) -> Option<()> {
|
||||
let mut consumed = false;
|
||||
for player in self.get_item_carriers_in_zone(player_id).unwrap_or(vec![]) {
|
||||
player.items_update(items);
|
||||
consumed = true;
|
||||
}
|
||||
|
||||
if !consumed {
|
||||
info!("Storing not consumed items for player id: {}", player_id);
|
||||
self.unconsumed_items.insert(player_id, items.clone());
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn register_main_player(&mut self, name: &str, id: usize) {
|
||||
info!("Main player {} registered with id {}", name, id);
|
||||
self.main_player_id = Some(id);
|
||||
|
||||
if self.zone_session.is_none() {
|
||||
self.new_session();
|
||||
}
|
||||
self.add_player(name, id, true);
|
||||
if let Some(items) = self.unconsumed_items.get(&id) {
|
||||
let i = items.clone();
|
||||
self.register_item_update(id, &i);
|
||||
self.unconsumed_items.remove(&id);
|
||||
}
|
||||
}
|
||||
|
||||
fn register_leave(&mut self, id: usize) -> Option<()> {
|
||||
let main_player_id = self.main_player_id?;
|
||||
if id == main_player_id {
|
||||
info!(
|
||||
"Main player ({}) left the zone, Creating new zone session.",
|
||||
id
|
||||
);
|
||||
self.zone_session_mut()?.cleanup_players();
|
||||
self.new_session();
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn register_player(&mut self, name: &str, id: usize) {
|
||||
if self.zone_session.is_none() {
|
||||
info!(
|
||||
"New player ({}) registered without session, creating new session",
|
||||
name
|
||||
);
|
||||
self.new_session();
|
||||
}
|
||||
|
||||
if self
|
||||
.get_damage_dealers_in_zone(id)
|
||||
.unwrap_or(vec![])
|
||||
.is_empty()
|
||||
{
|
||||
self.add_player(name, id, false);
|
||||
}
|
||||
}
|
||||
|
||||
fn register_combat_enter(&mut self, player_id: usize) -> Option<()> {
|
||||
if self.combat_state() == CombatState::OutOfCombat {
|
||||
self.last_fight_session = Session::from(&self.last_fight_session);
|
||||
}
|
||||
for player in self.get_damage_dealers_in_zone(player_id)? {
|
||||
player.enter_combat();
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
}
|
||||
|
||||
impl LastFightStats for Meter {
|
||||
fn last_fight_stats(&self) -> Option<PlayerStatisticsVec> {
|
||||
let last_session = &self.last_fight_session;
|
||||
@@ -266,13 +264,3 @@ impl GameStats for Meter {
|
||||
Some(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_meter() {
|
||||
let mut meter = Meter::new();
|
||||
|
||||
assert_eq!(meter.zone_stats(), None);
|
||||
|
||||
meter.register_main_player("name", 0);
|
||||
assert!(meter.zone_stats().is_some());
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@ use fake_clock::FakeClock as Instant;
|
||||
#[cfg(not(test))]
|
||||
use std::time::Instant;
|
||||
|
||||
use super::game_messages::Items;
|
||||
use super::photon_messages::Items;
|
||||
|
||||
use super::traits::CombatState;
|
||||
use super::traits::DamageDealer;
|
||||
|
||||
@@ -12,7 +12,7 @@ use super::player::Player;
|
||||
use super::traits::CombatState;
|
||||
use super::types::PlayerStatisticsVec;
|
||||
|
||||
#[derive(Debug)]
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Session {
|
||||
players: HashMap<String, Player>,
|
||||
}
|
||||
@@ -62,18 +62,6 @@ impl Session {
|
||||
)
|
||||
}
|
||||
|
||||
pub fn cleanup_players(&mut self) {
|
||||
let without_dmg = self
|
||||
.players
|
||||
.iter()
|
||||
.filter(|(_, player)| !player.main() && player.damage() == 0.0 && player.fame() == 0.0)
|
||||
.map(|(name, _)| name.clone())
|
||||
.collect::<Vec<String>>();
|
||||
for w in without_dmg {
|
||||
self.players.remove_entry(&w);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn players(&self) -> Vec<&Player> {
|
||||
self.players.iter().map(|(_, p)| p).collect()
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@ use fake_clock::FakeClock as Instant;
|
||||
use std::time::Instant;
|
||||
|
||||
use super::types::PlayerStatisticsVec;
|
||||
use super::game_messages::Items;
|
||||
use super::photon_messages::Items;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum CombatState {
|
||||
@@ -61,56 +61,6 @@ pub trait ItemCarrier {
|
||||
fn items(&self) -> Items;
|
||||
}
|
||||
|
||||
pub trait PlayerEvents {
|
||||
fn get_damage_dealers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn DamageDealer>>;
|
||||
|
||||
fn get_fame_gatherers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn FameGatherer>>;
|
||||
|
||||
fn get_item_carriers_in_zone(&mut self, player_id: usize) -> Option<Vec<&mut dyn ItemCarrier>>;
|
||||
|
||||
fn register_main_player(&mut self, name: &str, id: usize);
|
||||
|
||||
fn register_leave(&mut self, id: usize) -> Option<()>;
|
||||
|
||||
fn register_player(&mut self, name: &str, id: usize);
|
||||
|
||||
fn register_item_update(&mut self, player_id: usize, items: &Items) -> Option<()>;
|
||||
|
||||
fn register_fame_gain(&mut self, player_id: usize, fame: f32) -> Option<()> {
|
||||
for player in self.get_fame_gatherers_in_zone(player_id)? {
|
||||
player.register_fame_gain(fame);
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn register_damage_dealt(&mut self, player_id: usize, damage: f32) -> Option<()> {
|
||||
for player in self.get_damage_dealers_in_zone(player_id)? {
|
||||
if damage < 0.0 {
|
||||
player.register_damage_dealt(f32::abs(damage));
|
||||
}
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn register_combat_enter(&mut self, player_id: usize) -> Option<()> {
|
||||
for player in self.get_damage_dealers_in_zone(player_id)? {
|
||||
player.enter_combat();
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn register_combat_leave(&mut self, player_id: usize) -> Option<()> {
|
||||
for player in self.get_damage_dealers_in_zone(player_id)? {
|
||||
player.leave_combat();
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
}
|
||||
|
||||
pub trait LastFightStats {
|
||||
fn last_fight_stats(&self) -> Option<PlayerStatisticsVec>;
|
||||
fn reset_last_fight_stats(&mut self) -> Option<()>;
|
||||
|
||||
@@ -5,7 +5,7 @@ use fake_clock::FakeClock as Instant;
|
||||
#[cfg(not(test))]
|
||||
use std::time::Instant;
|
||||
|
||||
use super::game_messages::Items;
|
||||
use super::photon_messages::Items;
|
||||
use super::traits::DamageStats;
|
||||
use super::traits::FameStats;
|
||||
|
||||
@@ -24,7 +24,7 @@ pub struct PlayerStatistics {
|
||||
pub main_player_stats: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
#[derive(Debug, PartialEq, Clone, Default)]
|
||||
pub struct PlayerStatisticsVec {
|
||||
_vec: Vec<PlayerStatistics>,
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use log::*;
|
||||
use crate::game_messages::Items;
|
||||
use crate::photon_messages::Items;
|
||||
use photon_decode::Parameters;
|
||||
use photon_decode::Value;
|
||||
|
||||
@@ -114,7 +114,7 @@ macro_rules! decode_float {
|
||||
};
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct Leave {
|
||||
pub source: usize,
|
||||
|
||||
@@ -130,7 +130,7 @@ impl Leave {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct HealthUpdate {
|
||||
pub source: usize,
|
||||
pub target: usize,
|
||||
@@ -150,7 +150,7 @@ impl HealthUpdate {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct RegenerationHealthChanged {
|
||||
pub source: usize,
|
||||
pub health: f32,
|
||||
@@ -172,7 +172,7 @@ impl RegenerationHealthChanged {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct KnockedDown {
|
||||
pub source: usize,
|
||||
pub target: usize,
|
||||
@@ -192,7 +192,7 @@ impl KnockedDown {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct NewCharacter {
|
||||
pub source: usize,
|
||||
pub character_name: String,
|
||||
@@ -221,7 +221,7 @@ impl NewCharacter {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct UpdateFame {
|
||||
pub source: usize,
|
||||
pub fame: usize,
|
||||
@@ -239,7 +239,7 @@ impl UpdateFame {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct CharacterEquipmentChanged {
|
||||
pub source: usize,
|
||||
pub items: Items,
|
||||
@@ -258,7 +258,7 @@ impl CharacterEquipmentChanged {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct Join {
|
||||
pub source: usize,
|
||||
pub character_name: String,
|
||||
@@ -284,7 +284,7 @@ impl Join {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Message {
|
||||
Leave(Leave),
|
||||
HealthUpdate(HealthUpdate),
|
||||
@@ -0,0 +1,49 @@
|
||||
use crate::game::Event;
|
||||
|
||||
pub type Subscriber = dyn FnMut(Event) + Send;
|
||||
pub type Subscribers = Vec<Box<Subscriber>>;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Publisher {
|
||||
subscribers: Subscribers
|
||||
}
|
||||
|
||||
impl Publisher {
|
||||
pub fn new(subscribers: Subscribers) -> Self {
|
||||
Self {subscribers, ..Default::default()}
|
||||
}
|
||||
|
||||
pub fn publish(&mut self, event: &Event) {
|
||||
for subscriber in &mut self.subscribers {
|
||||
subscriber(event.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use std::thread;
|
||||
|
||||
#[test]
|
||||
fn test_simple_subscription() {
|
||||
let subscriber = |_| {};
|
||||
|
||||
let mut publisher = Publisher::new(vec![Box::new(subscriber)]);
|
||||
publisher.publish(&Event::ZoneChange);
|
||||
}
|
||||
|
||||
pub fn test_call_in_the_thread(subscribers: Subscribers)
|
||||
{
|
||||
thread::spawn(move || {
|
||||
let mut publisher = Publisher::new(subscribers);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_threads() {
|
||||
test_call_in_the_thread(vec![]);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
use packet_sniffer::UdpPacket;
|
||||
use photon_decode::Photon;
|
||||
|
||||
use crate::game::Event;
|
||||
use crate::photon_messages::into_game_message;
|
||||
use crate::photon_messages::Message;
|
||||
use crate::game::World;
|
||||
|
||||
use log::*;
|
||||
|
||||
static GAME_PORT : u16 = 5056;
|
||||
|
||||
pub fn udp_packet_to_game_events(game_world: &mut World, photon: &mut Photon, packet: &UdpPacket) -> Vec<Event> {
|
||||
if ! is_packet_valid(packet) {
|
||||
return vec![]
|
||||
}
|
||||
|
||||
debug!("Raw payload: {:?}", &packet.payload);
|
||||
|
||||
raw_to_photon_messages(photon, &packet.payload)
|
||||
.into_iter()
|
||||
.map(|message| game_world.transform(message))
|
||||
.flatten()
|
||||
.flatten()
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn raw_to_photon_messages(photon: &mut Photon, packet_payload: &[u8]) -> Vec<Message> {
|
||||
return photon
|
||||
.decode(packet_payload)
|
||||
.into_iter()
|
||||
.filter_map(into_game_message)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn is_packet_valid(packet: &UdpPacket) -> bool {
|
||||
return packet.destination_port == GAME_PORT || packet.source_port == GAME_PORT;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
from .app import run
|
||||
|
||||
@@ -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
|
||||
@@ -1,8 +1,8 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Helper script used to generate
|
||||
# - frontend/src/assets/item_category_map.json
|
||||
# - frontend/src/assets/localization.json
|
||||
# - application/src/assets/item_category_map.json
|
||||
# - application/src/assets/localization.json
|
||||
# - backend/assets/item_ids.txt
|
||||
# Args: path to directory containing files generated by ao-id-extractor
|
||||
# Usage python scripts/generate_assets.sh ${EXTRACTED}
|
||||
@@ -28,11 +28,11 @@ if [[ -z $localization_file ]]; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Generating frontend/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
|
||||
echo "Generating application/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..."
|
||||
python scripts/localization.py $localization_file | python -m json.tool > frontend/src/assets/localization.json
|
||||
echo "Generating application/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..."
|
||||
python scripts/item_id.py $items_file > backend/assets/item_ids.txt
|
||||
@@ -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
|
||||
# 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 re
|
||||
|
||||
@@ -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
|
||||
# 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 re
|
||||
|
||||