From 6720adc78b10fc364584e0436b9d0db08c6c7bdc Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Sun, 1 Mar 2020 20:24:57 +0100 Subject: [PATCH] Damage backward compatible with previous 0.8.1 --- application/src/backend_proxy.py | 66 +++++++++++--- application/src/consts/__init__.py | 0 application/src/consts/events.py | 14 +++ application/src/engine.py | 103 +++++++++++---------- application/src/environment.py | 13 ++- application/src/event_receiver.py | 125 ++++++++++++++++++++++++++ application/src/stats/damage_stats.py | 119 ++++++++++++++---------- application/src/stats/fame_stats.py | 15 ++++ application/src/stats/time_stats.py | 9 ++ application/src/stats/time_utils.py | 14 +++ 10 files changed, 371 insertions(+), 107 deletions(-) create mode 100644 application/src/consts/__init__.py create mode 100644 application/src/consts/events.py create mode 100644 application/src/event_receiver.py create mode 100644 application/src/stats/fame_stats.py create mode 100644 application/src/stats/time_stats.py create mode 100644 application/src/stats/time_utils.py diff --git a/application/src/backend_proxy.py b/application/src/backend_proxy.py index 9104463..7b1a275 100644 --- a/application/src/backend_proxy.py +++ b/application/src/backend_proxy.py @@ -11,6 +11,8 @@ except: pass from .environment import TEST_ENV_ENABLED +from . import environment + class InitializationResult: Ok = 0 @@ -24,13 +26,14 @@ INITIALIZATION_RESULT = { 2: InitializationResult.NetworkInterfaceListMissing } + def initialize(): if TEST_ENV_ENABLED: return InitializationResult.Ok try: result = aostats.initialize() - + return INITIALIZATION_RESULT[result] except: pass @@ -39,7 +42,7 @@ def initialize(): def subscribe(callback): if TEST_ENV_ENABLED: return _testing_call_sequence(callback) - + aostats.subscribe(callback) @@ -50,11 +53,23 @@ def _testing_call_sequence(callback): {'name': 'UpdateItems', 'value': {'source': id, 'value': { 'weapon': weapon}}}, ] + + def deal_damage(id, name, damage): + return [ + {'name': 'EnterCombat', 'value': {'id': id, 'name': name}}, + {'name': 'DamageDone', 'value': {'source': id, 'value': damage}}, + {'sleep': 0.1}, + {'name': 'LeaveCombat', 'value': {'id': id, 'name': name}}, + ] + import threading import time - sequence = [ + + sequence = {} + sequence[environment.TestType.Simple] = [ {'name': 'ZoneChange'}, - *add_player(0, 'Arcane', 'T4_MAIN_ARCANESTAFF@3', event_name='MainPlayerAppeared'), + *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'), @@ -69,18 +84,45 @@ def _testing_call_sequence(callback): *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'}}, + *deal_damage(2, 'Fire', 80.0), + *deal_damage(3, 'Frost', 200.0), + *deal_damage(6, 'Axe', 150.0), + *deal_damage(7, 'Dagger', 175.0), + *deal_damage(8, 'Hammer', 80.0), + *deal_damage(9, 'Mace', 80.0), + *deal_damage(10, 'Quarterstaff', 199.0), + *deal_damage(11, 'Spear', 96.0), + *deal_damage(12, 'Sword', 80.0), + *deal_damage(13, 'Bow', 221.0), + {'name': 'UpdateFame', 'value': {'value': 2000}}, + ] + + sequence[environment.TestType.ZoneChange] = [ + {'name': 'ZoneChange'}, + *add_player(0, 'Arcane', 'T4_MAIN_ARCANESTAFF@3', + event_name='MainPlayerAppeared'), + *add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'), + *add_player(3, 'Frost', 'T5_MAIN_FROSTSTAFF@1'), + *add_player(6, 'Axe', 'T8_MAIN_AXE'), + *add_player(7, 'Dagger', 'T8_MAIN_DAGGER@2'), + *add_player(8, 'Hammer', 'T7_MAIN_HAMMER@2'), + *deal_damage(2, 'Fire', 80.0), + *deal_damage(3, 'Frost', 200.0), + *deal_damage(6, 'Axe', 150.0), + *deal_damage(7, 'Dagger', 175.0), + *deal_damage(8, 'Hammer', 80.0), + {'name': 'UpdateFame', 'value': {'value': 2000}}, + {'name': 'ZoneChange'}, + *add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'), + *deal_damage(2, 'Fire', 80.0), + {'name': 'UpdateFame', 'value': {'value': 1000}}, ] def run_sequence(): - for v in sequence: + for v in sequence[environment.test_type]: if 'sleep' in v: time.sleep(v['sleep']) - else: + else: callback(v) thread = threading.Thread(target=run_sequence, daemon=True) - thread.start() \ No newline at end of file + thread.start() diff --git a/application/src/consts/__init__.py b/application/src/consts/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/application/src/consts/events.py b/application/src/consts/events.py new file mode 100644 index 0000000..a07a384 --- /dev/null +++ b/application/src/consts/events.py @@ -0,0 +1,14 @@ +EvNameMainPlayerAppeared : str = 'MainPlayerAppeared' +EvNamePlayerAppeared : str = 'PlayerAppeared' +EvNameDamageDone : str = 'DamageDone' +EvNameHealthReceived : str = 'HealthReceived' +EvNameZoneChange : str = 'ZoneChange' +EvNameEnterCombat : str = 'EnterCombat' +EvNameLeaveCombat : str = 'LeaveCombat' +EvNameUpdateFame : str = 'UpdateFame' +EvNameUpdateItems : str = 'UpdateItems' + +EvKeyName : str = 'name' +EvKeyValue : str = 'value' +EvKeySource : str = 'source' +EvKeyId : str = 'id' \ No newline at end of file diff --git a/application/src/engine.py b/application/src/engine.py index aafd848..a8fa3d2 100644 --- a/application/src/engine.py +++ b/application/src/engine.py @@ -4,7 +4,9 @@ from .environment import TEST_ENV_ENABLED from . import backend_proxy from .backend_proxy import InitializationResult, INITIALIZATION_RESULT -from .stats import damage_stats +from .stats import damage_stats, fame_stats +from .consts import events as ev_consts + class StatType: Unknown = 0 @@ -12,61 +14,71 @@ class StatType: Zone = 2 Overall = 3 -class GameStats: + +class GameStats(): def __init__(self): - self.zone = damage_stats.DamageStats() - self.last_fight = damage_stats.DamageStats() - self.overall = [] + self.zone = { + 'damage': damage_stats.DamageStats(), + 'fame': fame_stats.FameStats(), + } + self.last_fight = { + 'damage': damage_stats.DamageStats(), + 'fame': fame_stats.FameStats(), + } + self.history = { + 'damage': damage_stats.DamageStats(), + 'fame': damage_stats.DamageStats() + } 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() + if event[ev_consts.EvKeyName] == ev_consts.EvNameEnterCombat: + if self._are_everyone_in_session_out_of_combat(): + self.last_fight['damage'] = damage_stats.DamageStats.from_other( + self.zone['damage']) + elif event[ev_consts.EvKeyName] == ev_consts.EvNameZoneChange: + self.history['damage'].update(self.zone['damage']) + # self.history['fame'].update(self.zone['fame']) - elif event['name'] == 'UpdateFame': - pass - elif event['name'] == 'UpdateItems': - self.zone.add_items( - event['value']['source'], event['value']['value']) + self.zone['damage'] = damage_stats.DamageStats() + self.zone['fame'] = fame_stats.FameStats() + + self.zone['damage'].receive(event) + self.last_fight['damage'].receive(event) + self.zone['fame'].receive(event) + self.last_fight['fame'].receive(event) def reset(self, stat_type): if stat_type == StatType.Zone: - self.zone = damage_stats.DamageStats() - self.last_fight = damage_stats.DamageStats() + self.zone['damage'] = damage_stats.DamageStats() + self.last_fight['damage'] = damage_stats.DamageStats() elif stat_type == StatType.LastFight: - self.last_fight = damage_stats.DamageStats() + self.last_fight['damage'] = damage_stats.DamageStats() elif stat_type == StatType.Overall: - self.zone = damage_stats.DamageStats() - self.last_fight = [] + self.zone['damage'] = damage_stats.DamageStats() + self.last_fight['damage'] = [] def damage_stats(self, stat_type): if stat_type == StatType.Zone: - return self.zone.stats() + return self.zone['damage'].stats() elif stat_type == StatType.LastFight: - return self.last_fight.stats() + return self.last_fight['damage'].stats() elif stat_type == StatType.Overall: - return damage_stats.combined_stats(self.overall + self.zone.stats()) + return self.history['damage'].combined(self.zone['damage']).stats() + + def _are_everyone_in_session_out_of_combat(self): + return all(player.combat_state == damage_stats.CombatState.OutOfCombat for player in self.zone['damage'].players.values()) + + def _merged_stats(self, stats: dict): + result = {} + + for stat in stats: + result.update(stat.stats()) + + return result game_stats = GameStats() + class DamageStat: def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage): self.name = name @@ -137,22 +149,22 @@ def with_percentage(session): def zone_stats(with_damage=False): return stats({ - 'players': game_stats.damage_stats(StatType.Zone), - 'main': {}}, + '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': {}}, + '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': {}}, + 'players': game_stats.damage_stats(StatType.LastFight), + 'main': {}}, with_damage) @@ -167,6 +179,7 @@ def reset_last_fight_stats(): 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 index 37da738..69d125c 100644 --- a/application/src/environment.py +++ b/application/src/environment.py @@ -2,17 +2,22 @@ import os TEST_ENV_ENABLED = bool(os.getenv('TESTING')) + class TestType: - Simple = 1 + Simple = 'simple' + ZoneChange = 'zone_change' + _test_types = { - 'simple': TestType.Simple + TestType.Simple: TestType.Simple, + TestType.ZoneChange: TestType.ZoneChange } 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()))) + 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 + TEST_TYPE = _test_types[os.getenv('TESTING').lower()] diff --git a/application/src/event_receiver.py b/application/src/event_receiver.py new file mode 100644 index 0000000..26bf74e --- /dev/null +++ b/application/src/event_receiver.py @@ -0,0 +1,125 @@ +import abc + +from typing import Dict + +from .consts import events as consts + + +class EventReceiver(abc.ABC): + def receive(self, event): + event_name: Dict[str, str] = event[consts.EvKeyName] + value: dict = event[consts.EvKeyValue] if consts.EvKeyValue in event else None + + if event_name == consts.EvNameMainPlayerAppeared: + self.on_player_appeared( + value[consts.EvKeyId], value[consts.EvKeyName]) + elif event_name == consts.EvNamePlayerAppeared: + self.on_player_appeared( + value[consts.EvKeyId], value[consts.EvKeyName]) + elif event_name == consts.EvNameDamageDone: + self.on_damage_done( + value[consts.EvKeySource], value[consts.EvKeyValue]) + elif event_name == consts.EvNameHealthReceived: + self.on_health_received( + value[consts.EvKeySource], value[consts.EvKeyValue]) + elif event_name == consts.EvNameZoneChange: + self.on_zone_change() + elif event_name == consts.EvNameEnterCombat: + self.on_enter_combat(value[consts.EvKeyId]) + elif event_name == consts.EvNameLeaveCombat: + self.on_leave_combat(value[consts.EvKeyId]) + elif event_name == consts.EvNameUpdateFame: + self.on_fame_update(value[consts.EvKeyValue]) + elif event_name == consts.EvNameUpdateItems: + self.on_items_update( + value[consts.EvKeySource], value[consts.EvKeyValue]) + + @abc.abstractmethod + def on_player_appeared(self, id: int, name: str): + pass + + @abc.abstractmethod + def on_damage_done(self, id: int, damage: float): + pass + + @abc.abstractmethod + def on_health_received(self, id: int, health: float): + pass + + @abc.abstractmethod + def on_zone_change(self): + pass + + @abc.abstractmethod + def on_enter_combat(self, id: int): + pass + + @abc.abstractmethod + def on_leave_combat(self, id: int): + pass + + @abc.abstractmethod + def on_fame_update(self, value: float): + pass + + @abc.abstractmethod + def on_items_update(self, id: int, items: Dict[str, str]): + pass + + +class PassiveEventReceiver(EventReceiver): + def on_player_appeared(self, id: int, name: str): + pass + + def on_damage_done(self, id: int, damage: float): + pass + + def on_health_received(self, id: int, health: float): + pass + + def on_zone_change(self): + pass + + def on_enter_combat(self, id: int): + pass + + def on_leave_combat(self, id: int): + pass + + def on_fame_update(self, value: float): + pass + + def on_items_update(self, id: int, items: Dict[str, str]): + pass + + +class FameEventReceiver(PassiveEventReceiver): + @abc.abstractmethod + def on_fame_update(self, value: float): + pass + + +class CombatEventReceiver(PassiveEventReceiver): + @abc.abstractmethod + def on_player_appeared(self, id: int, name: str): + pass + + @abc.abstractmethod + def on_damage_done(self, id: int, damage: float): + pass + + @abc.abstractmethod + def on_health_received(self, id: int, health: float): + pass + + @abc.abstractmethod + def on_enter_combat(self, id: int): + pass + + @abc.abstractmethod + def on_leave_combat(self, id: int): + pass + + @abc.abstractmethod + def on_items_update(self, id: int, items: Dict[str, str]): + pass \ No newline at end of file diff --git a/application/src/stats/damage_stats.py b/application/src/stats/damage_stats.py index 974d78d..513c06d 100644 --- a/application/src/stats/damage_stats.py +++ b/application/src/stats/damage_stats.py @@ -7,53 +7,67 @@ # 'weapon': 'T5_MAIN_CURSEDSTAFF@2' # } -from datetime import datetime +from dataclasses import field +from dataclasses import dataclass +from typing import Optional + +from . import time_utils +from ..event_receiver import CombatEventReceiver +@dataclass +class CombatTime: + entered_combat: Optional[float] = None + time_in_combat: float = 0.0 + + +class CombatState: + InCombat = 1 + OutOfCombat = 2 + + +@dataclass 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 + name: str + items: dict = field(default_factory=lambda: {'weapon': None}) + damage_done: float = 0.0 + combat_time: CombatTime = CombatTime() + combat_state: CombatState = CombatState.OutOfCombat @staticmethod def from_other(other): - Player(other.name) + return Player(other.name, other.items) + + def update(self, other): + self.name = other.name + self.damage_done += other.damage_done + self.combat_time.time_in_combat += other.combat_time.time_in_combat + self.items = other.items def register_items(self, value): self.items = value def register_damage_done(self, value): - if self.combat_state == self.CombatState.OutOfCombat: + if self.combat_state == CombatState.OutOfCombat: return self.damage_done += value def enter_combat(self): - self.combat_time.entered_combat = datetime.now() - self.combat_state = self.CombatState.InCombat + self.combat_time.entered_combat = time_utils.now() + self.combat_state = 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 + self.combat_time.time_in_combat += time_utils.delta( + self.combat_time.entered_combat) + self.combat_state = CombatState.OutOfCombat @property def time_in_combat(self): - if self.combat_state == self.CombatState.InCombat: + if self.combat_state == 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 + time_utils.delta(self.combat_time.entered_combat) return self.combat_time.time_in_combat @@ -61,9 +75,8 @@ class Player: def dps(self): if self.time_in_combat == 0.0: return 0.0 - - return (self.damage_done / self.time_in_combat) * 1000.0 + return time_utils.as_seconds(self.damage_done / self.time_in_combat) def stats(self): return { @@ -74,7 +87,7 @@ class Player: 'items': self.items} -class DamageStats: +class DamageStats(CombatEventReceiver): def __init__(self, players=None): if not players: players = {} @@ -82,32 +95,51 @@ class DamageStats: @staticmethod def from_other(other): - DamageStats({k: Player.from_other(v)} for k, v in other.players) + return DamageStats({k: Player.from_other(v) for (k, v) in other.players.items()}) - def add_player(self, player_id, name): - if player_id not in self.players: - self.players[player_id] = Player(name) + def update(self, other): + for (id, player) in other.players.items(): + if id in self.players: + self.players[id].update(player) + else: + self.players[id] = Player.from_other(player) + self.players[id].update(player) - def add_items(self, player_id, items): - self.players[player_id].register_items(items) + def combined(self, other): + stats = DamageStats() + stats.update(self) + stats.update(other) - 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) + return stats def stats(self): return [player.stats() for player in self.players.values()] + def on_player_appeared(self, id: int, name: str): + if id not in self.players: + self.players[id] = Player(name) + + def on_damage_done(self, id: int, damage: float): + self.players[id].register_damage_done(damage) + + def on_health_received(self): + pass + + def on_enter_combat(self, id: int): + self.players[id].enter_combat() + + def on_leave_combat(self, id: int): + self.players[id].leave_combat() + + def on_items_update(self, id: int, items: dict): + self.players[id].register_items(items) + def combined_stats(stats_list): combined = {} for stats in stats_list: + print(stats) if stats['player'] in combined: current = combined[stats['player']] current['damage'] += stats['damage'] @@ -118,8 +150,3 @@ def combined_stats(stats_list): 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/stats/fame_stats.py b/application/src/stats/fame_stats.py new file mode 100644 index 0000000..873d723 --- /dev/null +++ b/application/src/stats/fame_stats.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass + +from ..event_receiver import FameEventReceiver + + +@dataclass +class FameStats(FameEventReceiver): + fame: float = 0.0 + + def __init__(self): + self.fame = 0.0 + + def on_fame_update(self, value: float): + self.fame += value + diff --git a/application/src/stats/time_stats.py b/application/src/stats/time_stats.py new file mode 100644 index 0000000..f061673 --- /dev/null +++ b/application/src/stats/time_stats.py @@ -0,0 +1,9 @@ +from . import time_utils + + +class TimeStats: + def __init__(self): + self.time = time_utils.now() + + def stats(self): + return time_utils.delta(self.time) \ No newline at end of file diff --git a/application/src/stats/time_utils.py b/application/src/stats/time_utils.py new file mode 100644 index 0000000..9736525 --- /dev/null +++ b/application/src/stats/time_utils.py @@ -0,0 +1,14 @@ +from datetime import datetime + + +def now(): + return datetime.now() + + +def delta(time): + delta = datetime.now() - time + return (delta.seconds * 1000.0 + delta.microseconds / 1000.0) + + +def as_seconds(time): + return time * 1000.0 \ No newline at end of file