+ 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}},
]
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:
+1
View File
@@ -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'
+47 -31
View File
@@ -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 = {}
@@ -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)
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):
+3 -1
View File
@@ -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:
+2 -2
View File
@@ -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
+9 -5
View File
@@ -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),
}
}
+2 -1
View File
@@ -1,2 +1,3 @@
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 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()
+2 -2
View File
@@ -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]:
+1 -1
View File
@@ -1 +1 @@
from libaostats import *
from libaostats import * # type: ignore