Damage backward compatible with previous 0.8.1

This commit is contained in:
Wiktor Mazur
2020-03-01 20:24:57 +01:00
parent 133975cd77
commit 6720adc78b
10 changed files with 371 additions and 107 deletions
+50 -8
View File
@@ -11,6 +11,8 @@ except:
pass pass
from .environment import TEST_ENV_ENABLED from .environment import TEST_ENV_ENABLED
from . import environment
class InitializationResult: class InitializationResult:
Ok = 0 Ok = 0
@@ -24,6 +26,7 @@ INITIALIZATION_RESULT = {
2: InitializationResult.NetworkInterfaceListMissing 2: InitializationResult.NetworkInterfaceListMissing
} }
def initialize(): def initialize():
if TEST_ENV_ENABLED: if TEST_ENV_ENABLED:
return InitializationResult.Ok return InitializationResult.Ok
@@ -50,11 +53,23 @@ def _testing_call_sequence(callback):
{'name': 'UpdateItems', 'value': {'source': id, 'value': { {'name': 'UpdateItems', 'value': {'source': id, 'value': {
'weapon': weapon}}}, '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 threading
import time import time
sequence = [
sequence = {}
sequence[environment.TestType.Simple] = [
{'name': 'ZoneChange'}, {'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(1, 'Cursed', 'T5_MAIN_CURSEDSTAFF@2'),
*add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'), *add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'),
*add_player(3, 'Frost', 'T5_MAIN_FROSTSTAFF@1'), *add_player(3, 'Frost', 'T5_MAIN_FROSTSTAFF@1'),
@@ -69,15 +84,42 @@ def _testing_call_sequence(callback):
*add_player(12, 'Sword', 'T7_2H_CLAYMORE@2'), *add_player(12, 'Sword', 'T7_2H_CLAYMORE@2'),
*add_player(13, 'Bow', 'T8_2H_BOW@2'), *add_player(13, 'Bow', 'T8_2H_BOW@2'),
*add_player(14, 'Crossbow', 'T8_2H_CROSSBOWLARGE@3'), *add_player(14, 'Crossbow', 'T8_2H_CROSSBOWLARGE@3'),
{'name': 'EnterCombat', 'value': {'id': 0, 'name': 'Arcane'}}, *deal_damage(2, 'Fire', 80.0),
{'sleep': 1}, *deal_damage(3, 'Frost', 200.0),
{'name': 'DamageDone', 'value': {'source': 0, 'value': 100.0}}, *deal_damage(6, 'Axe', 150.0),
{'sleep': 1.2}, *deal_damage(7, 'Dagger', 175.0),
{'name': 'LeaveCombat', 'value': {'id': 0, 'name': 'Arcane'}}, *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(): def run_sequence():
for v in sequence: for v in sequence[environment.test_type]:
if 'sleep' in v: if 'sleep' in v:
time.sleep(v['sleep']) time.sleep(v['sleep'])
else: else:
View File
+14
View File
@@ -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'
+52 -39
View File
@@ -4,7 +4,9 @@ from .environment import TEST_ENV_ENABLED
from . import backend_proxy from . import backend_proxy
from .backend_proxy import InitializationResult, INITIALIZATION_RESULT 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: class StatType:
Unknown = 0 Unknown = 0
@@ -12,61 +14,71 @@ class StatType:
Zone = 2 Zone = 2
Overall = 3 Overall = 3
class GameStats:
class GameStats():
def __init__(self): def __init__(self):
self.zone = damage_stats.DamageStats() self.zone = {
self.last_fight = damage_stats.DamageStats() 'damage': damage_stats.DamageStats(),
self.overall = [] '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): def register_event(self, event):
if event['name'] == 'MainPlayerAppeared': if event[ev_consts.EvKeyName] == ev_consts.EvNameEnterCombat:
self.zone.add_player( if self._are_everyone_in_session_out_of_combat():
event['value']['id'], event['value']['name']) self.last_fight['damage'] = damage_stats.DamageStats.from_other(
elif event['name'] == 'PlayerAppeared': self.zone['damage'])
self.zone.add_player( elif event[ev_consts.EvKeyName] == ev_consts.EvNameZoneChange:
event['value']['id'], event['value']['name']) self.history['damage'].update(self.zone['damage'])
elif event['name'] == 'DamageDone': # self.history['fame'].update(self.zone['fame'])
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()
elif event['name'] == 'UpdateFame': self.zone['damage'] = damage_stats.DamageStats()
pass self.zone['fame'] = fame_stats.FameStats()
elif event['name'] == 'UpdateItems':
self.zone.add_items( self.zone['damage'].receive(event)
event['value']['source'], event['value']['value']) self.last_fight['damage'].receive(event)
self.zone['fame'].receive(event)
self.last_fight['fame'].receive(event)
def reset(self, stat_type): def reset(self, stat_type):
if stat_type == StatType.Zone: if stat_type == StatType.Zone:
self.zone = damage_stats.DamageStats() self.zone['damage'] = damage_stats.DamageStats()
self.last_fight = damage_stats.DamageStats() self.last_fight['damage'] = damage_stats.DamageStats()
elif stat_type == StatType.LastFight: elif stat_type == StatType.LastFight:
self.last_fight = damage_stats.DamageStats() self.last_fight['damage'] = damage_stats.DamageStats()
elif stat_type == StatType.Overall: elif stat_type == StatType.Overall:
self.zone = damage_stats.DamageStats() self.zone['damage'] = damage_stats.DamageStats()
self.last_fight = [] self.last_fight['damage'] = []
def damage_stats(self, stat_type): def damage_stats(self, stat_type):
if stat_type == StatType.Zone: if stat_type == StatType.Zone:
return self.zone.stats() return self.zone['damage'].stats()
elif stat_type == StatType.LastFight: elif stat_type == StatType.LastFight:
return self.last_fight.stats() return self.last_fight['damage'].stats()
elif stat_type == StatType.Overall: 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() game_stats = GameStats()
class DamageStat: class DamageStat:
def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage): def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage):
self.name = name self.name = name
@@ -167,6 +179,7 @@ def reset_last_fight_stats():
def reset_stats(): def reset_stats():
game_stats.reset(StatType.Overall) game_stats.reset(StatType.Overall)
def initialize(): def initialize():
backend_proxy.initialize() backend_proxy.initialize()
backend_proxy.subscribe(game_stats.register_event) backend_proxy.subscribe(game_stats.register_event)
+8 -3
View File
@@ -2,17 +2,22 @@ import os
TEST_ENV_ENABLED = bool(os.getenv('TESTING')) TEST_ENV_ENABLED = bool(os.getenv('TESTING'))
class TestType: class TestType:
Simple = 1 Simple = 'simple'
ZoneChange = 'zone_change'
_test_types = { _test_types = {
'simple': TestType.Simple TestType.Simple: TestType.Simple,
TestType.ZoneChange: TestType.ZoneChange
} }
if TEST_ENV_ENABLED: if TEST_ENV_ENABLED:
test_type = os.getenv('TESTING') test_type = os.getenv('TESTING')
if test_type not in _test_types: 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()] TEST_TYPE = _test_types[os.getenv('TESTING').lower()]
+125
View File
@@ -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
+70 -43
View File
@@ -7,53 +7,67 @@
# 'weapon': 'T5_MAIN_CURSEDSTAFF@2' # '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
class Player: @dataclass
class CombatTime: class CombatTime:
def __init__(self): entered_combat: Optional[float] = None
self.entered_combat = None time_in_combat: float = 0.0
self.time_in_combat = 0.0
class CombatState:
class CombatState:
InCombat = 1 InCombat = 1
OutOfCombat = 2 OutOfCombat = 2
def __init__(self, name):
self.name = name @dataclass
self.damage_done = 0.0 class Player:
self.items = {'weapon': None} name: str
self.combat_time = self.CombatTime() items: dict = field(default_factory=lambda: {'weapon': None})
self.combat_state = self.CombatState.OutOfCombat damage_done: float = 0.0
combat_time: CombatTime = CombatTime()
combat_state: CombatState = CombatState.OutOfCombat
@staticmethod @staticmethod
def from_other(other): 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): def register_items(self, value):
self.items = value self.items = value
def register_damage_done(self, value): def register_damage_done(self, value):
if self.combat_state == self.CombatState.OutOfCombat: if self.combat_state == CombatState.OutOfCombat:
return return
self.damage_done += value self.damage_done += value
def enter_combat(self): def enter_combat(self):
self.combat_time.entered_combat = datetime.now() self.combat_time.entered_combat = time_utils.now()
self.combat_state = self.CombatState.InCombat self.combat_state = CombatState.InCombat
def leave_combat(self): def leave_combat(self):
if self.combat_time.entered_combat: if self.combat_time.entered_combat:
self.combat_time.time_in_combat += _time_delta(self.combat_time.entered_combat) self.combat_time.time_in_combat += time_utils.delta(
self.combat_state = self.CombatState.OutOfCombat self.combat_time.entered_combat)
self.combat_state = CombatState.OutOfCombat
@property @property
def time_in_combat(self): def time_in_combat(self):
if self.combat_state == self.CombatState.InCombat: if self.combat_state == CombatState.InCombat:
if self.combat_time.entered_combat: 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 return self.combat_time.time_in_combat
@@ -62,8 +76,7 @@ class Player:
if self.time_in_combat == 0.0: if self.time_in_combat == 0.0:
return 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): def stats(self):
return { return {
@@ -74,7 +87,7 @@ class Player:
'items': self.items} 'items': self.items}
class DamageStats: class DamageStats(CombatEventReceiver):
def __init__(self, players=None): def __init__(self, players=None):
if not players: if not players:
players = {} players = {}
@@ -82,32 +95,51 @@ class DamageStats:
@staticmethod @staticmethod
def from_other(other): 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): def update(self, other):
if player_id not in self.players: for (id, player) in other.players.items():
self.players[player_id] = Player(name) 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): def combined(self, other):
self.players[player_id].register_items(items) stats = DamageStats()
stats.update(self)
stats.update(other)
def enter_combat(self, player_id): return stats
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)
def stats(self): def stats(self):
return [player.stats() for player in self.players.values()] 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): def combined_stats(stats_list):
combined = {} combined = {}
for stats in stats_list: for stats in stats_list:
print(stats)
if stats['player'] in combined: if stats['player'] in combined:
current = combined[stats['player']] current = combined[stats['player']]
current['damage'] += stats['damage'] current['damage'] += stats['damage']
@@ -118,8 +150,3 @@ def combined_stats(stats_list):
combined[stats['player']] = stats combined[stats['player']] = stats
return [s for s in combined.values()] return [s for s in combined.values()]
def _time_delta(time):
delta = datetime.now() - time
return (delta.seconds * 1000.0 + delta.microseconds / 1000.0)
+15
View File
@@ -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
+9
View File
@@ -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)
+14
View File
@@ -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