Files
aostats-custom/src/engine.py
T
bionickatana f3114b076a
Build / Build source distribution (push) Failing after 8s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
Added 'damage taken' section to the UI
2026-10-10 23:38:32 -06:00

302 lines
11 KiB
Python

import logging
from typing import Iterable
from dataclasses import dataclass
from queue import Queue
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 combat_stats, economy_stats, fame_stats, time_stats, combat_state
from .consts import events as ev_consts
from .event_receiver import VisibilityEventReceiver
from .stats.visibility import Visibility
logger = logging.getLogger(__name__)
@dataclass(frozen=True)
class VisibilityType:
LastFight: str = 'last_fight'
Zone: str = 'zone'
Overall: str = 'history'
@dataclass(frozen=True)
class StatType:
Combat: str = 'Combat'
Fame: str = 'Fame'
Time: str = 'Time'
Economy: str = 'Economy'
@dataclass(frozen=True)
class CombatStatType:
Damage: str = 'Damage'
DamageTaken: str = 'DamageTaken'
Healing: str = 'Healing'
class GameStats():
def __init__(self):
self.visibility = Visibility()
self.zone = {
StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
StatType.Economy: economy_stats.EconomyStats(),
}
self.last_fight = {
StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
StatType.Economy: economy_stats.EconomyStats(),
}
self.history = {
StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
StatType.Economy: economy_stats.EconomyStats(),
}
def register_event(self, event):
if event[ev_consts.EvKeyName] == ev_consts.EvNameEnterCombat:
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:
self.history[StatType.Combat].update_non_idle(
self.zone[StatType.Combat])
self.history[StatType.Fame].update(self.zone[StatType.Fame])
self.history[StatType.Time].update(self.zone[StatType.Time])
self.history[StatType.Economy].update(self.zone[StatType.Economy])
self._construct_new_stats([VisibilityType.Zone])
self.zone[StatType.Combat].receive(event)
self.last_fight[StatType.Combat].receive(event)
self.zone[StatType.Fame].receive(event)
self.last_fight[StatType.Fame].receive(event)
self.zone[StatType.Economy].receive(event)
self.last_fight[StatType.Economy].receive(event)
self.visibility.receive(event)
def reset(self, stat_type):
if stat_type == VisibilityType.Zone:
for t in (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy):
self.history[t].update(self.zone[t])
self._construct_new_stats(
(VisibilityType.Zone, VisibilityType.LastFight))
elif stat_type == VisibilityType.LastFight:
self._construct_new_stats([VisibilityType.LastFight])
elif stat_type == VisibilityType.Overall:
self._construct_new_stats(
(VisibilityType.Zone, VisibilityType.Overall, VisibilityType.LastFight))
def get_damage_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_damage()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Combat].players_damage()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage()
def get_damage_taken_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_damage_taken()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Combat].players_damage_taken()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage_taken()
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 get_total_healing_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_total_healing()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Combat].players_total_healing()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_total_healing()
def fame_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Fame].stats()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Fame].stats()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Fame].combined(self.zone[StatType.Fame]).stats()
def time_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Time].stats()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Time].stats()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Time].combined(self.zone[StatType.Time]).stats()
def economy_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Economy].stats()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Economy].stats()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).stats()
def item_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Economy].item_list()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Economy].item_list()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).item_list()
def silver_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Economy].silver_list()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Economy].silver_list()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).silver_list()
def _construct_new_stats(self, scope: Iterable[str]):
types = (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy)
for s in scope:
for t in types:
if t == StatType.Time:
getattr(self, s)[t] = time_stats.TimeStats()
elif t == StatType.Combat:
getattr(self, s)[t] = combat_stats.CombatStats.from_other(
getattr(self, s)[t])
elif t == StatType.Fame:
getattr(self, s)[t] = fame_stats.FameStats()
elif t == StatType.Economy:
getattr(self, s)[t] = economy_stats.EconomyStats()
game_stats = GameStats()
event_queue: Queue = Queue()
class FameStat:
def __init__(self, fame, fame_per_hour):
self.fame = fame
self.fame_per_hour = fame_per_hour
def zone_stats(combat_stat_type: str):
return get_stats(VisibilityType.Zone, combat_stat_type)
def overall_stats(combat_stat_type: str):
return get_stats(VisibilityType.Overall, combat_stat_type)
def last_fight_stats(combat_stat_type: str):
return get_stats(VisibilityType.LastFight, combat_stat_type)
def zone_total_healing_stats():
return game_stats.get_total_healing_stats(VisibilityType.Zone)
def overall_total_healing_stats():
return game_stats.get_total_healing_stats(VisibilityType.Overall)
def last_fight_total_healing_stats():
return game_stats.get_total_healing_stats(VisibilityType.LastFight)
cached_players = () # do not compute values if there is nothing in queue
cached_stat_type = None
cached_combat_stat_type = None
def _drain_events():
new_events = False
while not event_queue.empty():
new_events = True
game_stats.register_event(event_queue.get_nowait())
return new_events
def get_stats(stat_type: str, combat_stat_type: str):
global cached_players, cached_stat_type, cached_combat_stat_type
new_events = _drain_events()
fame = game_stats.fame_stats(stat_type)
time = game_stats.time_stats(stat_type)['seconds_in_game']
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 and cached_stat_type == stat_type and cached_combat_stat_type == combat_stat_type:
return (cached_players, fame, time)
cached_players = {
CombatStatType.Damage: lambda stat_type: game_stats.get_damage_stats(stat_type),
CombatStatType.DamageTaken: lambda stat_type: game_stats.get_damage_taken_stats(stat_type),
CombatStatType.Healing: lambda stat_type: game_stats.get_healing_stats(
stat_type)
}[combat_stat_type](stat_type)
cached_stat_type = stat_type
cached_combat_stat_type = combat_stat_type
return (cached_players, fame, time)
def economy_stats_for(stat_type: str):
_drain_events()
return game_stats.economy_stats(stat_type)
def item_stats_for(stat_type: str):
_drain_events()
return game_stats.item_stats(stat_type)
def silver_stats_for(stat_type: str):
_drain_events()
return game_stats.silver_stats(stat_type)
def queue_an_event(event):
event_queue.put(event)
logger.debug("event received: %s", event.get(ev_consts.EvKeyName))
def reset_zone_stats():
game_stats.reset(VisibilityType.Zone)
def reset_last_fight_stats():
game_stats.reset(VisibilityType.LastFight)
def reset_stats():
game_stats.reset(VisibilityType.Overall)
def is_ready():
return game_stats.visibility.is_main_player_visible
def initialize():
initialization_result = backend_proxy.initialize()
if not backend_proxy.subscribe(queue_an_event):
logger.error("packet capture backend subscription failed")
if initialization_result == InitializationResult.Ok:
return InitializationResult.UnknownFailure
return initialization_result