From 5a4465f964192aab0e8ae645cda34aeaa555fbf9 Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Tue, 17 Mar 2020 20:20:00 +0100 Subject: [PATCH] + healing done --- application/src/backend_proxy.py | 12 ++++ application/src/consts/events.py | 1 + application/src/engine.py | 82 +++++++++++++--------- application/src/environment.py | 4 +- application/src/event_receiver.py | 4 +- application/src/gui/modules/main.py | 14 ++-- application/src/gui/modules/view_type.py | 3 +- application/src/stats/combat_stats.py | 87 +++++++++++++++++++----- application/src/stats/list_item.py | 4 +- backend/aostats/__init__.py | 2 +- 10 files changed, 152 insertions(+), 61 deletions(-) diff --git a/application/src/backend_proxy.py b/application/src/backend_proxy.py index 82a3556..13f92f4 100644 --- a/application/src/backend_proxy.py +++ b/application/src/backend_proxy.py @@ -118,6 +118,18 @@ def _testing_call_sequence(callback): {'name': 'UpdateFame', 'value': {'value': 1000}}, ] + sequence[environment.TestType.Healing] = [ + {'name': 'ZoneChange'}, + *add_player(0, 'Arcane', 'T4_MAIN_ARCANESTAFF@3', + event_name='MainPlayerAppeared'), + *add_player(1, 'Fire', 'T5_MAIN_FIRESTAFF@1'), + {'name': 'EnterCombat', 'value': {'id': 0, 'name': 'Arcane'}}, + {'name': 'UpdateParty', 'value': {'player_names': ['Arcane', 'Fire']}}, + {'name': 'HealthReceived', 'value': {'source': 0, 'target': 1, 'value': 100.0}}, + {'name': 'HealthReceived', 'value': {'source': 0, 'target': 0, 'value': 100.0}}, + {'name': 'HealthReceived', 'value': {'source': 1, 'target': 0, 'value': 100.0}}, + ] + def run_sequence(): for v in sequence[environment.test_type]: if 'sleep' in v: diff --git a/application/src/consts/events.py b/application/src/consts/events.py index 2b5d036..e4144d3 100644 --- a/application/src/consts/events.py +++ b/application/src/consts/events.py @@ -12,5 +12,6 @@ EvNameUpdateParty : str = 'UpdateParty' EvKeyName : str = 'name' EvKeyValue : str = 'value' EvKeySource : str = 'source' +EvKeyTarget : str = 'target' EvKeyId : str = 'id' EvKeyPlayerNames : str = 'player_names' \ No newline at end of file diff --git a/application/src/engine.py b/application/src/engine.py index 0bec4d7..f2e33db 100644 --- a/application/src/engine.py +++ b/application/src/engine.py @@ -16,41 +16,47 @@ from .stats.visibility import Visibility @dataclass(frozen=True) class VisibilityType: - LastFight = 'last_fight' - Zone = 'zone' - Overall = 'history' + LastFight: str = 'last_fight' + Zone: str = 'zone' + Overall: str = 'history' @dataclass(frozen=True) class StatType: - Combat = 'Combat' - Fame = 'Fame' - Time = 'Time' + Combat: str = 'Combat' + Fame: str = 'Fame' + Time: str = 'Time' + + +@dataclass(frozen=True) +class CombatStatType: + Damage: str = 'Damage' + Healing: str = 'Healing' class GameStats(): def __init__(self): + self.visibility = Visibility() + self.zone = { - StatType.Combat: combat_stats.CombatStats(), + StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), } self.last_fight = { - StatType.Combat: combat_stats.CombatStats(), + StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), } self.history = { - StatType.Combat: combat_stats.CombatStats(), + StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), } - self.visibility = Visibility() - def register_event(self, event): if event[ev_consts.EvKeyName] == ev_consts.EvNameEnterCombat: - if self._are_everyone_in_session_out_of_combat(): + if self.zone[StatType.Combat].party_combat_state() == combat_state.CombatState.OutOfCombat: self._construct_new_stats([VisibilityType.LastFight]) elif event[ev_consts.EvKeyName] == ev_consts.EvNameZoneChange: @@ -78,13 +84,21 @@ class GameStats(): self._construct_new_stats( (VisibilityType.Zone, VisibilityType.Overall, VisibilityType.LastFight)) - def combat_stats(self, stat_type): + def get_damage_stats(self, stat_type): if stat_type == VisibilityType.Zone: - return self.zone[StatType.Combat].player_list(self.visibility) + return self.zone[StatType.Combat].players_damage() elif stat_type == VisibilityType.LastFight: - return self.last_fight[StatType.Combat].player_list(self.visibility) + return self.last_fight[StatType.Combat].players_damage() elif stat_type == VisibilityType.Overall: - return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).player_list(self.visibility) + return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage() + + def get_healing_stats(self, stat_type): + if stat_type == VisibilityType.Zone: + return self.zone[StatType.Combat].players_healing() + elif stat_type == VisibilityType.LastFight: + return self.last_fight[StatType.Combat].players_healing() + elif stat_type == VisibilityType.Overall: + return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_healing() def fame_stats(self, stat_type): if stat_type == VisibilityType.Zone: @@ -114,9 +128,6 @@ class GameStats(): elif t == StatType.Fame: getattr(self, s)[t] = fame_stats.FameStats() - def _are_everyone_in_session_out_of_combat(self): - return all(player.combat_state == combat_state.CombatState.OutOfCombat for player in self.zone[StatType.Combat].player_list(self.visibility)) - def _merged_stats(self, stats: dict): result = {} @@ -127,7 +138,7 @@ class GameStats(): game_stats = GameStats() -event_queue : Queue = Queue() +event_queue: Queue = Queue() class FameStat: @@ -136,23 +147,23 @@ class FameStat: self.fame_per_hour = fame_per_hour -def zone_stats(): - return get_stats(VisibilityType.Zone) +def zone_stats(combat_stat_type: str): + return get_stats(VisibilityType.Zone, combat_stat_type) -def overall_stats(): - return get_stats(VisibilityType.Overall) +def overall_stats(combat_stat_type: str): + return get_stats(VisibilityType.Overall, combat_stat_type) -def last_fight_stats(): - return get_stats(VisibilityType.LastFight) +def last_fight_stats(combat_stat_type: str): + return get_stats(VisibilityType.LastFight, combat_stat_type) cached_players = () # do not compute values if there is nothing in queue +cached_players_type = None - -def get_stats(stat_type: VisibilityType): - global cached_players +def get_stats(stat_type: str, combat_stat_type: str): + global cached_players, cached_players_type new_events = False while not event_queue.empty(): @@ -164,12 +175,17 @@ def get_stats(stat_type: VisibilityType): fame = FameStat(Number(fame['fame']), Number( (fame['fame'] / time) * 60 * 60 if time > 0.0 else 0.0)) - if not new_events and cached_players: + if not new_events and cached_players and cached_players_type != stat_type: return (cached_players, fame, time) - players = game_stats.combat_stats(stat_type) - - return (players, fame, time) + cached_players = { + CombatStatType.Damage: lambda stat_type : game_stats.get_damage_stats(stat_type), + CombatStatType.Healing: lambda stat_type : game_stats.get_healing_stats(stat_type) + }[combat_stat_type](stat_type) + + cached_players_type = stat_type + + return (cached_players, fame, time) def queue_an_event(event): diff --git a/application/src/environment.py b/application/src/environment.py index 0b253b2..e615a12 100644 --- a/application/src/environment.py +++ b/application/src/environment.py @@ -6,11 +6,13 @@ TEST_ENV_ENABLED = bool(os.getenv('TESTING')) class TestType: Simple = 'simple' ZoneChange = 'zone_change' + Healing = 'healing' _test_types = { TestType.Simple: TestType.Simple, - TestType.ZoneChange: TestType.ZoneChange + TestType.ZoneChange: TestType.ZoneChange, + TestType.Healing: TestType.Healing } if TEST_ENV_ENABLED: diff --git a/application/src/event_receiver.py b/application/src/event_receiver.py index 4baf435..63a7ab0 100644 --- a/application/src/event_receiver.py +++ b/application/src/event_receiver.py @@ -57,7 +57,7 @@ class CombatEventReceiver(EventReceiver): value[consts.EvKeySource], value[consts.EvKeyValue]) elif event_name == consts.EvNameHealthReceived: self.on_health_received( - value[consts.EvKeySource], value[consts.EvKeyValue]) + value[consts.EvKeySource], value[consts.EvKeyTarget], value[consts.EvKeyValue]) elif event_name == consts.EvNameEnterCombat: self.on_enter_combat(value[consts.EvKeyId]) elif event_name == consts.EvNameLeaveCombat: @@ -75,7 +75,7 @@ class CombatEventReceiver(EventReceiver): pass @abc.abstractmethod - def on_health_received(self, id: int, health: float): + def on_health_received(self, id: int, target_id: int, health: float): pass @abc.abstractmethod diff --git a/application/src/gui/modules/main.py b/application/src/gui/modules/main.py index 4a1e530..1a04161 100644 --- a/application/src/gui/modules/main.py +++ b/application/src/gui/modules/main.py @@ -50,7 +50,7 @@ class ViewTypeWidget(QComboBox): def __init__(self): QComboBox.__init__(self) self.addItem(ViewType.DMG) - self.setEnabled(False) + self.addItem(ViewType.HEALING_DONE) def get_view_type(self): return self.currentText() @@ -120,7 +120,6 @@ class MainWidget(QWidget): if any(region.contains(self.mouse_pos) for region in invalid_regions): return - if event.buttons() & Qt.LeftButton: diff = event.pos() - self.mouse_pos newpos = self.pos() + diff @@ -130,9 +129,14 @@ class MainWidget(QWidget): def damage_stats(self): stats = { ViewType.DMG: { - StatsType.ZONE: functools.partial(engine.zone_stats), - StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats), - StatsType.OVERALL: functools.partial(engine.overall_stats), + StatsType.ZONE: functools.partial(engine.zone_stats, engine.CombatStatType.Damage), + StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats, engine.CombatStatType.Damage), + StatsType.OVERALL: functools.partial(engine.overall_stats, engine.CombatStatType.Damage), + }, + ViewType.HEALING_DONE: { + StatsType.ZONE: functools.partial(engine.zone_stats, engine.CombatStatType.Healing), + StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats, engine.CombatStatType.Healing), + StatsType.OVERALL: functools.partial(engine.overall_stats, engine.CombatStatType.Healing), } } diff --git a/application/src/gui/modules/view_type.py b/application/src/gui/modules/view_type.py index 696f9a4..ef06f2d 100644 --- a/application/src/gui/modules/view_type.py +++ b/application/src/gui/modules/view_type.py @@ -1,2 +1,3 @@ class ViewType: - DMG = 'Stats (damage)' + DMG: str = 'Stats (damage done)' + HEALING_DONE: str = 'Stats (healing done)' diff --git a/application/src/stats/combat_stats.py b/application/src/stats/combat_stats.py index 3d691dc..bfbd2c2 100644 --- a/application/src/stats/combat_stats.py +++ b/application/src/stats/combat_stats.py @@ -9,7 +9,7 @@ from dataclasses import field from dataclasses import dataclass -from typing import Optional, List +from typing import Optional, List, Callable, Iterable from . import time_utils from ..event_receiver import CombatEventReceiver, VisibilityEventReceiver @@ -25,25 +25,46 @@ class CombatTime: time_in_combat: float = 0.0 +class Party: + def __init__(self, get_visible_players): + self.get_visible_players = get_visible_players + + def combat_state(self) -> int: + return CombatState.OutOfCombat if all( + player.combat_state == CombatState.InCombat for player in self.get_visible_players()) else CombatState.InCombat + + def time_in_combat(self) -> float: + longest = 0.0 + + for player in self.get_visible_players(): + if player.time_in_combat > longest: + longest = player.time_in_combat + + return longest + + @dataclass class Player(Stats): name: str + party: Party items: dict = field(default_factory=lambda: {'weapon': None}) damage_done: float = 0.0 + healing_done: float = 0.0 combat_time: CombatTime = field(default_factory=lambda: CombatTime()) combat_state: int = CombatState.OutOfCombat @staticmethod def new(self): - return Player() + raise Exception("Should never happen") @staticmethod def from_other(other): - return Player(other.name, other.items) + return Player(other.name, other.party, items=other.items) def update(self, other): self.name = other.name self.damage_done += other.damage_done + self.healing_done += other.healing_done self.combat_state = other.combat_state self.combat_time.entered_combat = other.combat_time.entered_combat self.combat_time.time_in_combat += other.combat_time.time_in_combat @@ -58,6 +79,12 @@ class Player(Stats): self.damage_done += value + def register_healing_done(self, value): + if self.party.combat_state() == CombatState.OutOfCombat: + return + + self.healing_done += value + def enter_combat(self): self.combat_time.entered_combat = time_utils.now() self.combat_state = CombatState.InCombat @@ -68,6 +95,14 @@ class Player(Stats): self.combat_time.entered_combat) self.combat_state = CombatState.OutOfCombat + def into_damage_list_item(self) -> StandalonePlayerListItem: + return StandalonePlayerListItem( + self.name, self.items, self.damage_done, self.dps, self.combat_state) + + def into_healing_list_item(self) -> StandalonePlayerListItem: + return StandalonePlayerListItem( + self.name, self.items, self.healing_done, self.hps, self.combat_state) + @property def time_in_combat(self): if self.combat_state == CombatState.InCombat: @@ -83,20 +118,31 @@ class Player(Stats): return time_utils.as_milliseconds(self.damage_done / self.time_in_combat) + @property + def hps(self): + time_in_combat = self.party.time_in_combat() + + if time_in_combat == 0.0: + return 0.0 + + return time_utils.as_milliseconds(self.healing_done / time_in_combat) + class CombatStats(CombatEventReceiver, Stats): - def __init__(self, players=None): + def __init__(self, visibility, players=None): + self.visibility = visibility + self.party = Party(self.visible_players) if not players: players = {} self.players = players @staticmethod def new(self): - return CombatStats() + raise Exception("Should never happen") @staticmethod def from_other(other): - return CombatStats({k: Player.from_other(v) for (k, v) in other.players.items()}) + return CombatStats(other.visibility, {k: Player.from_other(v) for (k, v) in other.players.items()}) def update(self, other): for (id, player) in other.players.items(): @@ -107,28 +153,37 @@ class CombatStats(CombatEventReceiver, Stats): self.players[id].update(player) def combined(self, other): - stats = CombatStats() + stats = CombatStats(self.visibility) stats.update(self) stats.update(other) return stats - def player_list(self, visibility: Visibility) -> List[PlayerListItem]: - return to_player_list_items([ - StandalonePlayerListItem( - player.name, player.items, player.damage_done, player.dps, player.combat_state) - for player in self.players.values() if visibility.test(player.name) - ]) + def players_damage(self) -> List[PlayerListItem]: + return to_player_list_items([player.into_damage_list_item() + for player in self.visible_players() + ]) + + def players_healing(self) -> List[PlayerListItem]: + return to_player_list_items([player.into_healing_list_item() + for player in self.visible_players() + ]) + + def party_combat_state(self): + return self.party.combat_state() + + def visible_players(self) -> Iterable[Player]: + return (player for player in self.players.values() if self.visibility.test(player.name)) def on_player_appeared(self, id: int, name: str): if id not in self.players: - self.players[id] = Player(name) + self.players[id] = Player(name, self.party) def on_damage_done(self, id: int, damage: float): self.players[id].register_damage_done(damage) - def on_health_received(self, id: int, damage: float): - pass + def on_health_received(self, id: int, target_id: int, health: float): + self.players[id].register_healing_done(health) def on_enter_combat(self, id: int): self.players[id].enter_combat() diff --git a/application/src/stats/list_item.py b/application/src/stats/list_item.py index 50cbda0..a0706e0 100644 --- a/application/src/stats/list_item.py +++ b/application/src/stats/list_item.py @@ -10,7 +10,7 @@ class StandalonePlayerListItem: items: dict value: float value_per_second: float - combat_state: CombatState + combat_state: int @dataclass @@ -21,7 +21,7 @@ class PlayerListItem: value_per_second: Number best_value: Number percentage: Number - combat_state: CombatState + combat_state: int def to_player_list_items(standalone_list: List[StandalonePlayerListItem]) -> List[PlayerListItem]: diff --git a/backend/aostats/__init__.py b/backend/aostats/__init__.py index 3832a76..4568801 100644 --- a/backend/aostats/__init__.py +++ b/backend/aostats/__init__.py @@ -1 +1 @@ -from libaostats import * +from libaostats import * # type: ignore