+ healing done

This commit is contained in:
Wiktor Mazur
2020-03-17 20:20:00 +01:00
parent 667a90f8e5
commit 5a4465f964
10 changed files with 152 additions and 61 deletions
+12
View File
@@ -118,6 +118,18 @@ def _testing_call_sequence(callback):
{'name': 'UpdateFame', 'value': {'value': 1000}}, {'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(): def run_sequence():
for v in sequence[environment.test_type]: for v in sequence[environment.test_type]:
if 'sleep' in v: if 'sleep' in v:
+1
View File
@@ -12,5 +12,6 @@ EvNameUpdateParty : str = 'UpdateParty'
EvKeyName : str = 'name' EvKeyName : str = 'name'
EvKeyValue : str = 'value' EvKeyValue : str = 'value'
EvKeySource : str = 'source' EvKeySource : str = 'source'
EvKeyTarget : str = 'target'
EvKeyId : str = 'id' EvKeyId : str = 'id'
EvKeyPlayerNames : str = 'player_names' EvKeyPlayerNames : str = 'player_names'
+48 -32
View File
@@ -16,41 +16,47 @@ from .stats.visibility import Visibility
@dataclass(frozen=True) @dataclass(frozen=True)
class VisibilityType: class VisibilityType:
LastFight = 'last_fight' LastFight: str = 'last_fight'
Zone = 'zone' Zone: str = 'zone'
Overall = 'history' Overall: str = 'history'
@dataclass(frozen=True) @dataclass(frozen=True)
class StatType: class StatType:
Combat = 'Combat' Combat: str = 'Combat'
Fame = 'Fame' Fame: str = 'Fame'
Time = 'Time' Time: str = 'Time'
@dataclass(frozen=True)
class CombatStatType:
Damage: str = 'Damage'
Healing: str = 'Healing'
class GameStats(): class GameStats():
def __init__(self): def __init__(self):
self.visibility = Visibility()
self.zone = { self.zone = {
StatType.Combat: combat_stats.CombatStats(), StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(), StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(), StatType.Time: time_stats.TimeStats(),
} }
self.last_fight = { self.last_fight = {
StatType.Combat: combat_stats.CombatStats(), StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(), StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(), StatType.Time: time_stats.TimeStats(),
} }
self.history = { self.history = {
StatType.Combat: combat_stats.CombatStats(), StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(), StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(), StatType.Time: time_stats.TimeStats(),
} }
self.visibility = Visibility()
def register_event(self, event): def register_event(self, event):
if event[ev_consts.EvKeyName] == ev_consts.EvNameEnterCombat: 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]) self._construct_new_stats([VisibilityType.LastFight])
elif event[ev_consts.EvKeyName] == ev_consts.EvNameZoneChange: elif event[ev_consts.EvKeyName] == ev_consts.EvNameZoneChange:
@@ -78,13 +84,21 @@ class GameStats():
self._construct_new_stats( self._construct_new_stats(
(VisibilityType.Zone, VisibilityType.Overall, VisibilityType.LastFight)) (VisibilityType.Zone, VisibilityType.Overall, VisibilityType.LastFight))
def combat_stats(self, stat_type): def get_damage_stats(self, stat_type):
if stat_type == VisibilityType.Zone: 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: 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: 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): def fame_stats(self, stat_type):
if stat_type == VisibilityType.Zone: if stat_type == VisibilityType.Zone:
@@ -114,9 +128,6 @@ class GameStats():
elif t == StatType.Fame: elif t == StatType.Fame:
getattr(self, s)[t] = fame_stats.FameStats() 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): def _merged_stats(self, stats: dict):
result = {} result = {}
@@ -127,7 +138,7 @@ class GameStats():
game_stats = GameStats() game_stats = GameStats()
event_queue : Queue = Queue() event_queue: Queue = Queue()
class FameStat: class FameStat:
@@ -136,23 +147,23 @@ class FameStat:
self.fame_per_hour = fame_per_hour self.fame_per_hour = fame_per_hour
def zone_stats(): def zone_stats(combat_stat_type: str):
return get_stats(VisibilityType.Zone) return get_stats(VisibilityType.Zone, combat_stat_type)
def overall_stats(): def overall_stats(combat_stat_type: str):
return get_stats(VisibilityType.Overall) return get_stats(VisibilityType.Overall, combat_stat_type)
def last_fight_stats(): def last_fight_stats(combat_stat_type: str):
return get_stats(VisibilityType.LastFight) return get_stats(VisibilityType.LastFight, combat_stat_type)
cached_players = () # do not compute values if there is nothing in queue cached_players = () # do not compute values if there is nothing in queue
cached_players_type = None
def get_stats(stat_type: str, combat_stat_type: str):
def get_stats(stat_type: VisibilityType): global cached_players, cached_players_type
global cached_players
new_events = False new_events = False
while not event_queue.empty(): while not event_queue.empty():
@@ -164,12 +175,17 @@ def get_stats(stat_type: VisibilityType):
fame = FameStat(Number(fame['fame']), Number( fame = FameStat(Number(fame['fame']), Number(
(fame['fame'] / time) * 60 * 60 if time > 0.0 else 0.0)) (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) return (cached_players, fame, time)
players = game_stats.combat_stats(stat_type) 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)
return (players, fame, time) cached_players_type = stat_type
return (cached_players, fame, time)
def queue_an_event(event): def queue_an_event(event):
+3 -1
View File
@@ -6,11 +6,13 @@ TEST_ENV_ENABLED = bool(os.getenv('TESTING'))
class TestType: class TestType:
Simple = 'simple' Simple = 'simple'
ZoneChange = 'zone_change' ZoneChange = 'zone_change'
Healing = 'healing'
_test_types = { _test_types = {
TestType.Simple: TestType.Simple, TestType.Simple: TestType.Simple,
TestType.ZoneChange: TestType.ZoneChange TestType.ZoneChange: TestType.ZoneChange,
TestType.Healing: TestType.Healing
} }
if TEST_ENV_ENABLED: if TEST_ENV_ENABLED:
+2 -2
View File
@@ -57,7 +57,7 @@ class CombatEventReceiver(EventReceiver):
value[consts.EvKeySource], value[consts.EvKeyValue]) value[consts.EvKeySource], value[consts.EvKeyValue])
elif event_name == consts.EvNameHealthReceived: elif event_name == consts.EvNameHealthReceived:
self.on_health_received( self.on_health_received(
value[consts.EvKeySource], value[consts.EvKeyValue]) value[consts.EvKeySource], value[consts.EvKeyTarget], value[consts.EvKeyValue])
elif event_name == consts.EvNameEnterCombat: elif event_name == consts.EvNameEnterCombat:
self.on_enter_combat(value[consts.EvKeyId]) self.on_enter_combat(value[consts.EvKeyId])
elif event_name == consts.EvNameLeaveCombat: elif event_name == consts.EvNameLeaveCombat:
@@ -75,7 +75,7 @@ class CombatEventReceiver(EventReceiver):
pass pass
@abc.abstractmethod @abc.abstractmethod
def on_health_received(self, id: int, health: float): def on_health_received(self, id: int, target_id: int, health: float):
pass pass
@abc.abstractmethod @abc.abstractmethod
+9 -5
View File
@@ -50,7 +50,7 @@ class ViewTypeWidget(QComboBox):
def __init__(self): def __init__(self):
QComboBox.__init__(self) QComboBox.__init__(self)
self.addItem(ViewType.DMG) self.addItem(ViewType.DMG)
self.setEnabled(False) self.addItem(ViewType.HEALING_DONE)
def get_view_type(self): def get_view_type(self):
return self.currentText() return self.currentText()
@@ -120,7 +120,6 @@ class MainWidget(QWidget):
if any(region.contains(self.mouse_pos) for region in invalid_regions): if any(region.contains(self.mouse_pos) for region in invalid_regions):
return return
if event.buttons() & Qt.LeftButton: if event.buttons() & Qt.LeftButton:
diff = event.pos() - self.mouse_pos diff = event.pos() - self.mouse_pos
newpos = self.pos() + diff newpos = self.pos() + diff
@@ -130,9 +129,14 @@ class MainWidget(QWidget):
def damage_stats(self): def damage_stats(self):
stats = { stats = {
ViewType.DMG: { ViewType.DMG: {
StatsType.ZONE: functools.partial(engine.zone_stats), StatsType.ZONE: functools.partial(engine.zone_stats, engine.CombatStatType.Damage),
StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats), StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats, engine.CombatStatType.Damage),
StatsType.OVERALL: functools.partial(engine.overall_stats), 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),
} }
} }
+2 -1
View File
@@ -1,2 +1,3 @@
class ViewType: class ViewType:
DMG = 'Stats (damage)' DMG: str = 'Stats (damage done)'
HEALING_DONE: str = 'Stats (healing done)'
+70 -15
View File
@@ -9,7 +9,7 @@
from dataclasses import field from dataclasses import field
from dataclasses import dataclass from dataclasses import dataclass
from typing import Optional, List from typing import Optional, List, Callable, Iterable
from . import time_utils from . import time_utils
from ..event_receiver import CombatEventReceiver, VisibilityEventReceiver from ..event_receiver import CombatEventReceiver, VisibilityEventReceiver
@@ -25,25 +25,46 @@ class CombatTime:
time_in_combat: float = 0.0 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 @dataclass
class Player(Stats): class Player(Stats):
name: str name: str
party: Party
items: dict = field(default_factory=lambda: {'weapon': None}) items: dict = field(default_factory=lambda: {'weapon': None})
damage_done: float = 0.0 damage_done: float = 0.0
healing_done: float = 0.0
combat_time: CombatTime = field(default_factory=lambda: CombatTime()) combat_time: CombatTime = field(default_factory=lambda: CombatTime())
combat_state: int = CombatState.OutOfCombat combat_state: int = CombatState.OutOfCombat
@staticmethod @staticmethod
def new(self): def new(self):
return Player() raise Exception("Should never happen")
@staticmethod @staticmethod
def from_other(other): def from_other(other):
return Player(other.name, other.items) return Player(other.name, other.party, items=other.items)
def update(self, other): def update(self, other):
self.name = other.name self.name = other.name
self.damage_done += other.damage_done self.damage_done += other.damage_done
self.healing_done += other.healing_done
self.combat_state = other.combat_state self.combat_state = other.combat_state
self.combat_time.entered_combat = other.combat_time.entered_combat self.combat_time.entered_combat = other.combat_time.entered_combat
self.combat_time.time_in_combat += other.combat_time.time_in_combat self.combat_time.time_in_combat += other.combat_time.time_in_combat
@@ -58,6 +79,12 @@ class Player(Stats):
self.damage_done += value 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): def enter_combat(self):
self.combat_time.entered_combat = time_utils.now() self.combat_time.entered_combat = time_utils.now()
self.combat_state = CombatState.InCombat self.combat_state = CombatState.InCombat
@@ -68,6 +95,14 @@ class Player(Stats):
self.combat_time.entered_combat) self.combat_time.entered_combat)
self.combat_state = CombatState.OutOfCombat 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 @property
def time_in_combat(self): def time_in_combat(self):
if self.combat_state == CombatState.InCombat: 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) 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): 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: if not players:
players = {} players = {}
self.players = players self.players = players
@staticmethod @staticmethod
def new(self): def new(self):
return CombatStats() raise Exception("Should never happen")
@staticmethod @staticmethod
def from_other(other): 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): def update(self, other):
for (id, player) in other.players.items(): for (id, player) in other.players.items():
@@ -107,28 +153,37 @@ class CombatStats(CombatEventReceiver, Stats):
self.players[id].update(player) self.players[id].update(player)
def combined(self, other): def combined(self, other):
stats = CombatStats() stats = CombatStats(self.visibility)
stats.update(self) stats.update(self)
stats.update(other) stats.update(other)
return stats return stats
def player_list(self, visibility: Visibility) -> List[PlayerListItem]: def players_damage(self) -> List[PlayerListItem]:
return to_player_list_items([ return to_player_list_items([player.into_damage_list_item()
StandalonePlayerListItem( for player in self.visible_players()
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_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): def on_player_appeared(self, id: int, name: str):
if id not in self.players: 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): def on_damage_done(self, id: int, damage: float):
self.players[id].register_damage_done(damage) self.players[id].register_damage_done(damage)
def on_health_received(self, id: int, damage: float): def on_health_received(self, id: int, target_id: int, health: float):
pass self.players[id].register_healing_done(health)
def on_enter_combat(self, id: int): def on_enter_combat(self, id: int):
self.players[id].enter_combat() self.players[id].enter_combat()
+2 -2
View File
@@ -10,7 +10,7 @@ class StandalonePlayerListItem:
items: dict items: dict
value: float value: float
value_per_second: float value_per_second: float
combat_state: CombatState combat_state: int
@dataclass @dataclass
@@ -21,7 +21,7 @@ class PlayerListItem:
value_per_second: Number value_per_second: Number
best_value: Number best_value: Number
percentage: Number percentage: Number
combat_state: CombatState combat_state: int
def to_player_list_items(standalone_list: List[StandalonePlayerListItem]) -> List[PlayerListItem]: def to_player_list_items(standalone_list: List[StandalonePlayerListItem]) -> List[PlayerListItem]:
+1 -1
View File
@@ -1 +1 @@
from libaostats import * from libaostats import * # type: ignore