diff --git a/.gitignore b/.gitignore index cf2fe19..b4a2176 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ damage-meter.log # Python +.tox .pytest_cache *.spec env diff --git a/.travis.yml b/.travis.yml index 9df4713..723ec3f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -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 diff --git a/README.md b/README.md index c1742d4..eaf2402 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/frontend/albion-online-stats.py b/application/albion-online-stats.py similarity index 100% rename from frontend/albion-online-stats.py rename to application/albion-online-stats.py diff --git a/frontend/environment.yml b/application/environment.yml similarity index 100% rename from frontend/environment.yml rename to application/environment.yml diff --git a/frontend/requirements.txt b/application/requirements.txt similarity index 100% rename from frontend/requirements.txt rename to application/requirements.txt diff --git a/application/src/__init__.py b/application/src/__init__.py new file mode 100644 index 0000000..68060bf --- /dev/null +++ b/application/src/__init__.py @@ -0,0 +1,4 @@ +from . import utils + +from .gui.app import run + diff --git a/frontend/src/assets/about.png b/application/src/assets/about.png similarity index 100% rename from frontend/src/assets/about.png rename to application/src/assets/about.png diff --git a/frontend/src/assets/close.png b/application/src/assets/close.png similarity index 100% rename from frontend/src/assets/close.png rename to application/src/assets/close.png diff --git a/frontend/src/assets/copy.png b/application/src/assets/copy.png similarity index 100% rename from frontend/src/assets/copy.png rename to application/src/assets/copy.png diff --git a/frontend/src/assets/item_category_map.json b/application/src/assets/item_category_map.json similarity index 100% rename from frontend/src/assets/item_category_map.json rename to application/src/assets/item_category_map.json diff --git a/frontend/src/assets/localization.json b/application/src/assets/localization.json similarity index 100% rename from frontend/src/assets/localization.json rename to application/src/assets/localization.json diff --git a/frontend/src/assets/reset.png b/application/src/assets/reset.png similarity index 100% rename from frontend/src/assets/reset.png rename to application/src/assets/reset.png diff --git a/application/src/backend_proxy.py b/application/src/backend_proxy.py new file mode 100644 index 0000000..9104463 --- /dev/null +++ b/application/src/backend_proxy.py @@ -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() \ No newline at end of file diff --git a/application/src/engine.py b/application/src/engine.py new file mode 100644 index 0000000..aafd848 --- /dev/null +++ b/application/src/engine.py @@ -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) diff --git a/application/src/environment.py b/application/src/environment.py new file mode 100644 index 0000000..37da738 --- /dev/null +++ b/application/src/environment.py @@ -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()] \ No newline at end of file diff --git a/application/src/gui/__init__.py b/application/src/gui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/frontend/src/about.py b/application/src/gui/about.py similarity index 100% rename from frontend/src/about.py rename to application/src/gui/about.py diff --git a/frontend/src/app.py b/application/src/gui/app.py similarity index 88% rename from frontend/src/app.py rename to application/src/gui/app.py index cbbacc1..ed01019 100644 --- a/frontend/src/app.py +++ b/application/src/gui/app.py @@ -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__'))) diff --git a/frontend/src/dmg_list.py b/application/src/gui/dmg_list.py similarity index 98% rename from frontend/src/dmg_list.py rename to application/src/gui/dmg_list.py index 77980f8..b6efd02 100644 --- a/frontend/src/dmg_list.py +++ b/application/src/gui/dmg_list.py @@ -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') diff --git a/frontend/src/main.py b/application/src/gui/main.py similarity index 98% rename from frontend/src/main.py rename to application/src/gui/main.py index 1656a79..9767fcb 100644 --- a/frontend/src/main.py +++ b/application/src/gui/main.py @@ -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: diff --git a/frontend/src/styling.py b/application/src/gui/styling.py similarity index 91% rename from frontend/src/styling.py rename to application/src/gui/styling.py index 2242c59..a188f89 100644 --- a/frontend/src/styling.py +++ b/application/src/gui/styling.py @@ -1,4 +1,4 @@ -from .config import config +from ..utils.config import config cfg = config() font_size = cfg['window']['font-size'] diff --git a/application/src/stats/__init__.py b/application/src/stats/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/application/src/stats/damage_stats.py b/application/src/stats/damage_stats.py new file mode 100644 index 0000000..974d78d --- /dev/null +++ b/application/src/stats/damage_stats.py @@ -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) \ No newline at end of file diff --git a/application/src/utils/__init__.py b/application/src/utils/__init__.py new file mode 100644 index 0000000..94c255b --- /dev/null +++ b/application/src/utils/__init__.py @@ -0,0 +1,2 @@ +from . import number +from . import config \ No newline at end of file diff --git a/frontend/src/assets.py b/application/src/utils/assets.py similarity index 85% rename from frontend/src/assets.py rename to application/src/utils/assets.py index 288cd26..d4f6c95 100644 --- a/frontend/src/assets.py +++ b/application/src/utils/assets.py @@ -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) \ No newline at end of file diff --git a/frontend/src/async_request.py b/application/src/utils/async_request.py similarity index 100% rename from frontend/src/async_request.py rename to application/src/utils/async_request.py diff --git a/frontend/src/config.py b/application/src/utils/config.py similarity index 100% rename from frontend/src/config.py rename to application/src/utils/config.py diff --git a/frontend/src/names.py b/application/src/utils/names.py similarity index 100% rename from frontend/src/names.py rename to application/src/utils/names.py diff --git a/frontend/src/number.py b/application/src/utils/number.py similarity index 100% rename from frontend/src/number.py rename to application/src/utils/number.py diff --git a/frontend/src/version.py b/application/src/utils/version.py similarity index 100% rename from frontend/src/version.py rename to application/src/utils/version.py diff --git a/frontend/src/weapon.py b/application/src/utils/weapon.py similarity index 100% rename from frontend/src/weapon.py rename to application/src/utils/weapon.py diff --git a/frontend/tests/conftest.py b/application/tests/conftest.py similarity index 100% rename from frontend/tests/conftest.py rename to application/tests/conftest.py diff --git a/frontend/tests/test_number.py b/application/tests/test_number.py similarity index 95% rename from frontend/tests/test_number.py rename to application/tests/test_number.py index 2a66ef5..fd6499b 100644 --- a/frontend/tests/test_number.py +++ b/application/tests/test_number.py @@ -1,6 +1,6 @@ import pytest -from number import Number +from src.number import Number def test_number_equality(): n = 10 diff --git a/application/tox.ini b/application/tox.ini new file mode 100644 index 0000000..c5f8382 --- /dev/null +++ b/application/tox.ini @@ -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 \ No newline at end of file diff --git a/appveyor.yml b/appveyor.yml index 8906631..0bf0c81 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -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 diff --git a/backend/Cargo.lock b/backend/Cargo.lock index b5fff89..efa9696 100644 --- a/backend/Cargo.lock +++ b/backend/Cargo.lock @@ -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", ] diff --git a/backend/Cargo.toml b/backend/Cargo.toml index f6088bf..6a0c112 100644 --- a/backend/Cargo.toml +++ b/backend/Cargo.toml @@ -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" diff --git a/backend/build.rs b/backend/build.rs index 70e4585..a05ade8 100644 --- a/backend/build.rs +++ b/backend/build.rs @@ -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(); } diff --git a/backend/lib/photon-decode/.gitignore b/backend/lib/photon-decode/.gitignore new file mode 100644 index 0000000..41bbc13 --- /dev/null +++ b/backend/lib/photon-decode/.gitignore @@ -0,0 +1,4 @@ +&.rs.bk +/target +*.so +.vscode \ No newline at end of file diff --git a/backend/lib/photon-decode/Cargo.lock b/backend/lib/photon-decode/Cargo.lock new file mode 100644 index 0000000..920e478 --- /dev/null +++ b/backend/lib/photon-decode/Cargo.lock @@ -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" diff --git a/backend/lib/photon-decode/Cargo.toml b/backend/lib/photon-decode/Cargo.toml new file mode 100644 index 0000000..28247b5 --- /dev/null +++ b/backend/lib/photon-decode/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "photon_decode" +version = "0.2.1" +authors = ["Wiktor Mazur "] +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" diff --git a/backend/lib/photon-decode/README.md b/backend/lib/photon-decode/README.md new file mode 100644 index 0000000..7719ea2 --- /dev/null +++ b/backend/lib/photon-decode/README.md @@ -0,0 +1,59 @@ +Photon decode +============= + +Set of utilities for decoding messages generated by *photon framework. + +*Photon is a development framework for multiplayer games. More on https://www.photonengine.com/. + +[![Documentation](https://docs.rs/photon_decode/badge.svg)](https://docs.rs/photon_decode/*/photon_decode/) + + +## Usage + +To use `photon_decode`, first add this to your `Cargo.toml`: + +```toml +[dependencies] +photon_decode = "0.1" +``` + + +```rust +use photon_decode::{Photon, Message}; + +let mut photon = Photon::new(); +let photon_packet = vec![ + 0x00, 0x01, // PeerID + 0x01, // CrcEnabled + 0x00, // CommandCount + 0x00, 0x00, 0x00, 0x01, // Timestamp + 0x00, 0x00, 0x00, 0x01, // Challenge +]; + +for message in photon.decode(&photon_packet).iter() { + match message { + Message::Event(_) => { + // use event + }, + Message::Request(_) => { + // use request + }, + Message::Response(_) => { + // use response + } + } +} + +``` + +# Projects using photon decode + +https://github.com/mazurwiktor/albion-online-stats - Albion online stats is an extension to MMORPG game - Albion Online. It tracks network traffic and displays various statistics, such as damage and DPS meter calculated from in-game actions. + +# License +Licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) + +at your option. \ No newline at end of file diff --git a/backend/lib/photon-decode/src/decode.rs b/backend/lib/photon-decode/src/decode.rs new file mode 100644 index 0000000..53129fa --- /dev/null +++ b/backend/lib/photon-decode/src/decode.rs @@ -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 { + fn decode(&mut self) -> PhotonDecodeResult; +} + +trait TypedDecode { + fn typed_decode(&mut self, type_code: u8) -> PhotonDecodeResult; +} + +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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + let size: i16 = self.decode()?; + if size < 0 { + return Err(PhotonDecodeError::from( + "Failed to decode String, unreasonable size", + )); + } + let mut value: Vec = vec![]; + for _ in 0..size { + value.push(self.decode()?); + } + + Ok(value) + } +} + +impl Decode> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + let size: u32 = self.decode()?; + let mut value: Vec = vec![]; + for _ in 0..size { + value.push(self.decode()?); + } + + Ok(value) + } +} + +impl Decode> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + let size: i16 = self.decode()?; + if size < 0 { + return Err(PhotonDecodeError::from( + "Failed to decode Vec, unreasonable size", + )); + } + let type_code: u8 = self.decode()?; + + let mut value: Vec = vec![]; + for _ in 0..size { + if let Ok(v) = self.typed_decode(type_code) { + value.push(v); + } else { + break; + } + } + + Ok(value) + } +} + +impl Decode> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + 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, unreasonable size", + )); + } + + let mut value: HashMap = 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> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + let size: i16 = self.decode()?; + if size < 0 { + return Err(PhotonDecodeError::from( + "Failed to decode HashMap, unreasonable size", + )); + } + + let mut value: HashMap = 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + let code: u8 = self.decode()?; + let parameters: HashMap = self.decode()?; + Ok(EventData { code, parameters }) + } +} + +impl Decode for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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 = self.decode()?; + + Ok(OperationResponse { + code, + return_code, + debug_message, + parameters, + }) + } +} + +impl Decode for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + let code: u8 = self.decode()?; + let parameters: HashMap = self.decode()?; + Ok(OperationRequest { code, parameters }) + } +} + +impl Decode>> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult>> { + let size: i16 = self.decode()?; + if size < 0 { + return Err(PhotonDecodeError::from( + "Failed to decode Vec>, 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> for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult> { + let size: i16 = self.decode()?; + if size < 0 { + return Err(PhotonDecodeError::from( + "Failed to decode Vec, 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 { + 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + let type_code: u8 = self.decode()?; + self.typed_decode(type_code) + } +} + +impl Decode for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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::() 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + let mut reliable_command: ReliableCommand = self.decode()?; + let unknown = self.decode()?; + reliable_command.msg_len = reliable_command.msg_len.checked_sub(size_of::() as u32) + .map_or(Err(PhotonDecodeError::from("Invalid UnreliableCommand length")), |v| Ok(v))?; + Ok(UnreliableCommand { + reliable_command, + unknown, + }) + } +} + +impl Decode for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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::() * 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 for PhotonCursor<'_> { + fn decode(&mut self) -> PhotonDecodeResult { + 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::::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 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 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), + } + } +} diff --git a/backend/lib/photon-decode/src/error.rs b/backend/lib/photon-decode/src/error.rs new file mode 100644 index 0000000..987e1eb --- /dev/null +++ b/backend/lib/photon-decode/src/error.rs @@ -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 = std::result::Result; + +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 for PhotonDecodeError { + fn from(msg: String) -> PhotonDecodeError { + PhotonDecodeError { cause: msg } + } +} diff --git a/backend/lib/photon-decode/src/layout.rs b/backend/lib/photon-decode/src/layout.rs new file mode 100644 index 0000000..955aca1 --- /dev/null +++ b/backend/lib/photon-decode/src/layout.rs @@ -0,0 +1,94 @@ +use std::collections::HashMap; + +#[derive(Clone, Debug, PartialEq)] +pub enum Value { + None, + Dictionary(HashMap), + StringArray(Vec), + Byte(u8), + Double(f64), + EventData(EventData), + Float(f32), + Integer(u32), + Short(i16), + Long(i64), + BooleanArray(Vec), + Boolean(bool), + OperationResponse(OperationResponse), + OperationRequest(OperationRequest), + String(String), + ByteArray(Vec), + Array(Vec), + Object(Box), + ObjectArray(Vec>), +} + +pub type Parameters = HashMap; + +#[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, +} + +pub enum Command { + LogOut, + SendUnreliable(ReliableCommand), + SendReliable(ReliableCommand), + SendReliableFragment(ReliableFragment), +} diff --git a/backend/lib/photon-decode/src/lib.rs b/backend/lib/photon-decode/src/lib.rs new file mode 100644 index 0000000..916a8e6 --- /dev/null +++ b/backend/lib/photon-decode/src/lib.rs @@ -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 { + 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>, +} + +impl Photon { + pub fn new() -> Self { + Self { + fragments: HashMap::new(), + } + } + + pub fn try_decode( + &mut self, + payload: &[u8], + ) -> PhotonDecodeResult>> { + let mut cursor = Cursor::new(payload); + Ok( + (0..Decode::::decode(&mut cursor)?.command_count) + .into_iter() + .map(|_| { + Decode::::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 { + 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> { + if let Some(fragments) = self.fragments.get(&fragment.sequence_number) { + if fragments.len() == fragment.fragment_count as usize { + let mut buf = Vec::::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 + } +} diff --git a/backend/lib/photon-decode/tests/decoding_tests.rs b/backend/lib/photon-decode/tests/decoding_tests.rs new file mode 100644 index 0000000..30177d9 --- /dev/null +++ b/backend/lib/photon-decode/tests/decoding_tests.rs @@ -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), + }; +} \ No newline at end of file diff --git a/backend/lib/photon-decode/tests/integration_tests.rs b/backend/lib/photon-decode/tests/integration_tests.rs new file mode 100644 index 0000000..1d0567d --- /dev/null +++ b/backend/lib/photon-decode/tests/integration_tests.rs @@ -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 + } + } + } +} \ No newline at end of file diff --git a/backend/src/api.rs b/backend/src/api.rs new file mode 100644 index 0000000..daf8897 --- /dev/null +++ b/backend/src/api.rs @@ -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, Receiver) = 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(); +} \ No newline at end of file diff --git a/backend/src/core.rs b/backend/src/core.rs deleted file mode 100644 index 5871945..0000000 --- a/backend/src/core.rs +++ /dev/null @@ -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 = Mutex::new(meter::Meter::new()); -} - -pub fn stats(meter: &meter::Meter, stat_type: StatType) -> Vec { - 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>, 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, Receiver) = 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) { - messages - .iter() - .for_each(|message| register_message(meter, &message)); -} - -fn register_message(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); - } -} diff --git a/backend/src/crosslang/mod.rs b/backend/src/crosslang/mod.rs new file mode 100644 index 0000000..c0a088c --- /dev/null +++ b/backend/src/crosslang/mod.rs @@ -0,0 +1 @@ +pub mod python; diff --git a/backend/src/crosslang/python/convert.rs b/backend/src/crosslang/python/convert.rs new file mode 100644 index 0000000..7659166 --- /dev/null +++ b/backend/src/crosslang/python/convert.rs @@ -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 + } +} diff --git a/backend/src/crosslang/python/mod.rs b/backend/src/crosslang/python/mod.rs new file mode 100644 index 0000000..575aeda --- /dev/null +++ b/backend/src/crosslang/python/mod.rs @@ -0,0 +1 @@ +pub mod convert; \ No newline at end of file diff --git a/backend/src/game/convert.rs b/backend/src/game/convert.rs new file mode 100644 index 0000000..117b2e5 --- /dev/null +++ b/backend/src/game/convert.rs @@ -0,0 +1,133 @@ +use std::convert::From; + +use crate::photon_messages::messages; + +use super::events; +use super::player::{StaticId, PlayerName}; + +pub struct EventIntermediate { + id: StaticId, + name: PlayerName, + message: Msg, +} + +impl EventIntermediate { + pub fn new( + id: StaticId, + name: PlayerName, + message: Msg, + ) -> Self { + Self { + id, + name, + message, + } + } +} + +pub struct EventList { + value: Vec, +} + +impl EventList { + pub fn new(list: Vec) -> Self { + Self { value: list } + } + + pub fn values(self) -> Vec { + self.value + } +} + +impl From> for events::Event { + fn from(intermediate: EventIntermediate) -> Self { + Self::PlayerAppeared(events::Player { + id: intermediate.id, + name: intermediate.message.character_name, + }) + } +} + +impl From> for EventList { + fn from(intermediate: EventIntermediate) -> 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> for events::Event { + fn from(intermediate: EventIntermediate) -> Self { + Self::MainPlayerAppeared(events::Player { + id: intermediate.id, + name: intermediate.message.character_name, + }) + } +} + +impl From> for events::Event { + fn from(intermediate: EventIntermediate) -> 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> for events::Event { + fn from(intermediate: EventIntermediate) -> 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> for events::Event { + fn from(intermediate: EventIntermediate) -> Self { + Self::LeaveCombat(events::Player { + id: intermediate.id, + name: intermediate.name.into(), + }) + } +} + +impl From> for events::Event { + fn from(intermediate: EventIntermediate) -> Self { + Self::UpdateFame(events::Fame { + source: intermediate.id, + value: intermediate.message.fame as f32 / 10000.0, + }) + } +} + +impl From> for events::Event { + fn from(intermediate: EventIntermediate) -> Self { + Self::UpdateItems(events::Items { + source: intermediate.id, + value: intermediate.message.items, + }) + } +} diff --git a/backend/src/game/events.rs b/backend/src/game/events.rs new file mode 100644 index 0000000..945cf1a --- /dev/null +++ b/backend/src/game/events.rs @@ -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, + 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), +} diff --git a/backend/src/game/id_cache.rs b/backend/src/game/id_cache.rs new file mode 100644 index 0000000..d73e92b --- /dev/null +++ b/backend/src/game/id_cache.rs @@ -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, + dyn_id_to_name: BiMap, + 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 { + 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 { + 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())) + ); + } +} diff --git a/backend/src/game/mod.rs b/backend/src/game/mod.rs new file mode 100644 index 0000000..ec6f7f3 --- /dev/null +++ b/backend/src/game/mod.rs @@ -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; \ No newline at end of file diff --git a/backend/src/game/player.rs b/backend/src/game/player.rs new file mode 100644 index 0000000..b1bbfa6 --- /dev/null +++ b/backend/src/game/player.rs @@ -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 + } +} \ No newline at end of file diff --git a/backend/src/game/unconsumed_messages.rs b/backend/src/game/unconsumed_messages.rs new file mode 100644 index 0000000..d856a25 --- /dev/null +++ b/backend/src/game/unconsumed_messages.rs @@ -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> +} + +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> { + let messages = self.messages.get(&id.into())?; + let result = messages.clone(); + self.messages.remove(&id.into()); + + return Some(result); + } +} \ No newline at end of file diff --git a/backend/src/game/world.rs b/backend/src/game/world.rs new file mode 100644 index 0000000..b16f520 --- /dev/null +++ b/backend/src/game/world.rs @@ -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, +} + +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> { + 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 { + 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( + &self, + static_id: StaticId, + msg: Msg, + ) -> Option> { + 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"); + } +} diff --git a/backend/src/lib.rs b/backend/src/lib.rs deleted file mode 100644 index 68edfa0..0000000 --- a/backend/src/lib.rs +++ /dev/null @@ -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>> -} - -impl PyMeter -{ - fn new() -> Self { - Self{value: None} - } - - fn initialize(&mut self, value: Arc>) { - self.value = Some(value); - } - - fn get(&mut self) -> Option>> { - self.value.clone() - } -} - - -lazy_static! { - static ref METER: Mutex = 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 { - 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 { - 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 = 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::>() - .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 { - 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 { - 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(()) -}); diff --git a/backend/src/lib_python.rs b/backend/src/lib_python.rs new file mode 100644 index 0000000..1615ea5 --- /dev/null +++ b/backend/src/lib_python.rs @@ -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> = 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 { + api::initialize(vec![ + Box::new(python_callbacks_subscriber) + ]).map_or(Ok(0), |_| {Ok(2)}) +} + +fn subscribe(_py: Python, callable: cpython::PyObject) -> PyResult { + 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(()) +}); diff --git a/backend/src/meter/mod.rs b/backend/src/meter/mod.rs index 44c90e9..e12ceb1 100644 --- a/backend/src/meter/mod.rs +++ b/backend/src/meter/mod.rs @@ -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, last_fight_session: Session, - main_player_id: Option, - unconsumed_items: HashMap, - config: MeterConfig, + unconsumed_items: HashMap, } 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> { + 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> { - 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> { - 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> { - 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 { 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()); -} diff --git a/backend/src/meter/player.rs b/backend/src/meter/player.rs index 0a3e2c3..c54aac9 100644 --- a/backend/src/meter/player.rs +++ b/backend/src/meter/player.rs @@ -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; diff --git a/backend/src/meter/session.rs b/backend/src/meter/session.rs index 1ea577e..cca9044 100644 --- a/backend/src/meter/session.rs +++ b/backend/src/meter/session.rs @@ -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, } @@ -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::>(); - for w in without_dmg { - self.players.remove_entry(&w); - } - } - pub fn players(&self) -> Vec<&Player> { self.players.iter().map(|(_, p)| p).collect() } diff --git a/backend/src/meter/traits.rs b/backend/src/meter/traits.rs index 9269a32..a1044db 100644 --- a/backend/src/meter/traits.rs +++ b/backend/src/meter/traits.rs @@ -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>; - - fn get_fame_gatherers_in_zone(&mut self, player_id: usize) -> Option>; - - fn get_item_carriers_in_zone(&mut self, player_id: usize) -> Option>; - - 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; fn reset_last_fight_stats(&mut self) -> Option<()>; diff --git a/backend/src/meter/types.rs b/backend/src/meter/types.rs index 0bdf81d..ce68980 100644 --- a/backend/src/meter/types.rs +++ b/backend/src/meter/types.rs @@ -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, } diff --git a/backend/src/game_messages/itemdb.rs b/backend/src/photon_messages/itemdb.rs similarity index 100% rename from backend/src/game_messages/itemdb.rs rename to backend/src/photon_messages/itemdb.rs diff --git a/backend/src/game_messages/messages.rs b/backend/src/photon_messages/messages.rs similarity index 95% rename from backend/src/game_messages/messages.rs rename to backend/src/photon_messages/messages.rs index 24d5606..525aad9 100644 --- a/backend/src/game_messages/messages.rs +++ b/backend/src/photon_messages/messages.rs @@ -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), diff --git a/backend/src/game_messages/mod.rs b/backend/src/photon_messages/mod.rs similarity index 100% rename from backend/src/game_messages/mod.rs rename to backend/src/photon_messages/mod.rs diff --git a/backend/src/publisher.rs b/backend/src/publisher.rs new file mode 100644 index 0000000..6f0ff3a --- /dev/null +++ b/backend/src/publisher.rs @@ -0,0 +1,49 @@ +use crate::game::Event; + +pub type Subscriber = dyn FnMut(Event) + Send; +pub type Subscribers = Vec>; + +#[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![]); + } + +} \ No newline at end of file diff --git a/backend/src/translate.rs b/backend/src/translate.rs new file mode 100644 index 0000000..f71b723 --- /dev/null +++ b/backend/src/translate.rs @@ -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 { + 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 { + 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 { +} \ No newline at end of file diff --git a/frontend/src/__init__.py b/frontend/src/__init__.py deleted file mode 100644 index 3193130..0000000 --- a/frontend/src/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .app import run - diff --git a/frontend/src/engine.py b/frontend/src/engine.py deleted file mode 100644 index a5fa2ef..0000000 --- a/frontend/src/engine.py +++ /dev/null @@ -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 diff --git a/scripts/generate_assets.sh b/scripts/generate_assets.sh index a1c3518..d3fd098 100755 --- a/scripts/generate_assets.sh +++ b/scripts/generate_assets.sh @@ -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 \ No newline at end of file diff --git a/scripts/item_category_map.py b/scripts/item_category_map.py index 10cae5b..270be4f 100644 --- a/scripts/item_category_map.py +++ b/scripts/item_category_map.py @@ -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 diff --git a/scripts/localization.py b/scripts/localization.py index f819139..6d15b7e 100644 --- a/scripts/localization.py +++ b/scripts/localization.py @@ -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