Reduced backend resposibility to emmit game events, whole addon logic implemented in python side

This commit is contained in:
Wiktor Mazur
2020-02-18 16:55:33 +01:00
parent d73f34a33b
commit 133975cd77
78 changed files with 3203 additions and 1331 deletions
+3
View File
@@ -0,0 +1,3 @@
if __name__ == "__main__":
from src import run
run()
+12
View File
@@ -0,0 +1,12 @@
name: albion
channels:
- conda-forge
dependencies:
- rust=1.41
- pyside2=5.13.2
- pyinstaller=3.6
- toml=0.10.0
- requests=2.22
- pillow=7.0.0
+6
View File
@@ -0,0 +1,6 @@
pyside2~=5.13
pyinstaller
toml~=0.10
requests~=2.22
Pillow~=6.2
./backend
+4
View File
@@ -0,0 +1,4 @@
from . import utils
from .gui.app import run
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 785 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 835 B

File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
Binary file not shown.

After

Width:  |  Height:  |  Size: 648 B

+86
View File
@@ -0,0 +1,86 @@
try:
import aostats
except:
class aostats:
@staticmethod
def initialize(_):
return InitializationResult.NetworkInterfaceListMissing
@staticmethod
def subscribe(_):
pass
from .environment import TEST_ENV_ENABLED
class InitializationResult:
Ok = 0
UnknownFailure = 1
NetworkInterfaceListMissing = 2
INITIALIZATION_RESULT = {
0: InitializationResult.Ok,
1: InitializationResult.UnknownFailure,
2: InitializationResult.NetworkInterfaceListMissing
}
def initialize():
if TEST_ENV_ENABLED:
return InitializationResult.Ok
try:
result = aostats.initialize()
return INITIALIZATION_RESULT[result]
except:
pass
def subscribe(callback):
if TEST_ENV_ENABLED:
return _testing_call_sequence(callback)
aostats.subscribe(callback)
def _testing_call_sequence(callback):
def add_player(id, name, weapon, event_name='PlayerAppeared'):
return [
{'name': event_name, 'value': {'id': id, 'name': name}},
{'name': 'UpdateItems', 'value': {'source': id, 'value': {
'weapon': weapon}}},
]
import threading
import time
sequence = [
{'name': 'ZoneChange'},
*add_player(0, 'Arcane', 'T4_MAIN_ARCANESTAFF@3', event_name='MainPlayerAppeared'),
*add_player(1, 'Cursed', 'T5_MAIN_CURSEDSTAFF@2'),
*add_player(2, 'Fire', 'T5_MAIN_FIRESTAFF@1'),
*add_player(3, 'Frost', 'T5_MAIN_FROSTSTAFF@1'),
*add_player(4, 'Holy', 'T6_MAIN_HOLYSTAFF'),
*add_player(5, 'Nature', 'T8_MAIN_NATURESTAFF@3'),
*add_player(6, 'Axe', 'T8_MAIN_AXE'),
*add_player(7, 'Dagger', 'T8_MAIN_DAGGER@2'),
*add_player(8, 'Hammer', 'T7_MAIN_HAMMER@2'),
*add_player(9, 'Mace', 'T6_MAIN_MACE@2'),
*add_player(10, 'Quarterstaff', 'T5_2H_IRONCLADEDSTAFF@2'),
*add_player(11, 'Spear', 'T8_MAIN_SPEAR@2'),
*add_player(12, 'Sword', 'T7_2H_CLAYMORE@2'),
*add_player(13, 'Bow', 'T8_2H_BOW@2'),
*add_player(14, 'Crossbow', 'T8_2H_CROSSBOWLARGE@3'),
{'name': 'EnterCombat', 'value': {'id': 0, 'name': 'Arcane'}},
{'sleep': 1},
{'name': 'DamageDone', 'value': {'source': 0, 'value': 100.0}},
{'sleep': 1.2},
{'name': 'LeaveCombat', 'value': {'id': 0, 'name': 'Arcane'}},
]
def run_sequence():
for v in sequence:
if 'sleep' in v:
time.sleep(v['sleep'])
else:
callback(v)
thread = threading.Thread(target=run_sequence, daemon=True)
thread.start()
+172
View File
@@ -0,0 +1,172 @@
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 damage_stats
class StatType:
Unknown = 0
LastFight = 1
Zone = 2
Overall = 3
class GameStats:
def __init__(self):
self.zone = damage_stats.DamageStats()
self.last_fight = damage_stats.DamageStats()
self.overall = []
def register_event(self, event):
if event['name'] == 'MainPlayerAppeared':
self.zone.add_player(
event['value']['id'], event['value']['name'])
elif event['name'] == 'PlayerAppeared':
self.zone.add_player(
event['value']['id'], event['value']['name'])
elif event['name'] == 'DamageDone':
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':
pass
elif event['name'] == 'UpdateItems':
self.zone.add_items(
event['value']['source'], event['value']['value'])
def reset(self, stat_type):
if stat_type == StatType.Zone:
self.zone = damage_stats.DamageStats()
self.last_fight = damage_stats.DamageStats()
elif stat_type == StatType.LastFight:
self.last_fight = damage_stats.DamageStats()
elif stat_type == StatType.Overall:
self.zone = damage_stats.DamageStats()
self.last_fight = []
def damage_stats(self, stat_type):
if stat_type == StatType.Zone:
return self.zone.stats()
elif stat_type == StatType.LastFight:
return self.last_fight.stats()
elif stat_type == StatType.Overall:
return damage_stats.combined_stats(self.overall + self.zone.stats())
game_stats = GameStats()
class DamageStat:
def __init__(self, name, items, damage, time_in_combat, dps, percentage, best_damage):
self.name = name
self.items = items
self.damage = Number(damage)
self.time_in_combat = Number(time_in_combat)
self.dps = Number(dps)
self.percentage = Number(percentage)
self.best_damage = Number(best_damage)
def __str__(self):
return "Name {} Damage {} DPS {} percentage {} items {}".format(self.name, self.damage, self.dps, self.percentage, self.items)
def __eq__(self, other):
return self.name == other.name and self.damage == other.damage and self.time_in_combat == other.time_in_combat and self.dps == other.dps
class FameStat:
def __init__(self, fame, fame_per_hour):
self.fame = fame
self.fame_per_hour = fame_per_hour
def stats(session, with_dmg=False):
players = session['players']
main_player = session['main']
with_damage = [s for s in players if s['damage']
!= 0.0] if with_dmg else players
extended_session = with_percentage(with_damage)
statistics = [DamageStat(
s['player'],
s['items'],
s['damage'],
s['time_in_combat'],
s['dps'],
s['dmg_percentage'],
s['best_damage']) for s in extended_session]
elapsed = 0
fame = FameStat(Number(0.0), Number(0.0))
if main_player:
if 'fame' in main_player:
fame = FameStat(Number(main_player['fame']), Number(
main_player['fame_per_hour']))
if 'seconds_in_game' in main_player:
elapsed = main_player['seconds_in_game']
return statistics, fame, elapsed
def with_percentage(session):
best_damage = 0.0
damage_done = 0.0
for s in session:
damage = s['damage']
if damage > best_damage:
best_damage = damage
damage_done += damage
for s in session:
s['dmg_percentage'] = s['damage'] / \
damage_done * 100 if s['damage'] else 0.0
s['best_damage'] = best_damage
return session
def zone_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.Zone),
'main': {}},
with_damage)
def overall_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.Overall),
'main': {}},
with_damage)
def last_fight_stats(with_damage=False):
return stats({
'players': game_stats.damage_stats(StatType.LastFight),
'main': {}},
with_damage)
def reset_zone_stats():
game_stats.reset(StatType.Zone)
def reset_last_fight_stats():
game_stats.reset(StatType.LastFight)
def reset_stats():
game_stats.reset(StatType.Overall)
def initialize():
backend_proxy.initialize()
backend_proxy.subscribe(game_stats.register_event)
+18
View File
@@ -0,0 +1,18 @@
import os
TEST_ENV_ENABLED = bool(os.getenv('TESTING'))
class TestType:
Simple = 1
_test_types = {
'simple': TestType.Simple
}
if TEST_ENV_ENABLED:
test_type = os.getenv('TESTING')
if test_type not in _test_types:
raise Exception('Unavailable GUI test type, avaliable values: {}'.format(','.join(_test_types.keys())))
TEST_TYPE = _test_types[os.getenv('TESTING').lower()]
View File
+30
View File
@@ -0,0 +1,30 @@
from PySide2.QtWidgets import QMessageBox
text = """
This software is free to use and delivered to you with a lot on fun :)
If somebody ask you how to get it, just tell him/her to google 'albion online stats github'
Feel free to donate me with some in-game silver or support me on patronite.
Quick contact - catch me on discord JaWiktor#1717
See you in game, WedrowyczJakub
"""
class About(QMessageBox):
def __init__(self):
QMessageBox.__init__(self)
self.setIcon(QMessageBox.Information)
self.setWindowTitle("Albion online stats")
self.setText(text)
self.setInformativeText('<a href="{}"> Report Bug/Feature request </a> | <a href="{}"> Contribute </a> | <a href="{}"> Download </a> | <a href="{}"> Donate </a>'.format(
"https://github.com/mazurwiktor/albion-online-stats/issues/new/choose",
"https://github.com/mazurwiktor/albion-online-stats",
"https://github.com/mazurwiktor/albion-online-stats/releases/latest",
"https://www.patreon.com/wiktormazur",
))
self.setStandardButtons(QMessageBox.Ok)
+74
View File
@@ -0,0 +1,74 @@
from ..engine import InitializationResult
from ..engine import initialize
from ..utils.config import config
from .main import MainWidget
from .styling import style
from ..utils.version import current_version as get_current_version
from ..utils.version import latest_url
from ..utils.version import latest_version as get_latest_version
from PySide2.QtCore import Qt
from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QMessageBox
import os
import sys
sys.path.append(os.path.dirname(os.path.abspath('__file__')))
def run():
initialization_result = initialize()
conf = config()
window_config = conf['window']
WIDTH = window_config['width']
HEIGHT = window_config['height']
app = QApplication(sys.argv)
app.setStyleSheet(style)
geometry = app.screens()[0].size()
clipboard = app.clipboard()
widget = MainWidget(clipboard)
widget.setWindowOpacity(window_config['opacity'])
widget.resize(WIDTH, HEIGHT)
widget.move(0, geometry.height() - HEIGHT - 280)
widget.setWindowTitle('Damage Meter')
if window_config['always_on_top']:
widget.setWindowFlag(Qt.WindowStaysOnTopHint)
if window_config['frameless']:
widget.setWindowFlag(Qt.FramelessWindowHint)
widget.show()
current_version, latest_version = (
get_current_version(), get_latest_version())
if latest_version and current_version != latest_version:
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setWindowTitle("Update available!")
msg.setText("Another version of app is avaliable.")
msg.setInformativeText("You are using app in version {}, new version {} available <a href='{}'>here</a>".format(
current_version, latest_version, latest_url))
msg.setStandardButtons(QMessageBox.Ok)
msg.show()
if initialization_result == InitializationResult.NetworkInterfaceListMissing:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setWindowTitle("Unable to track network traffic data!")
msg.setText(
"On windows make sure that WinPcap is installed in your system.")
msg.setInformativeText("WinPcap can be installed from <a href='{}'>here</a> <br> <b>Make sure to install with the \"Install Npcap in WinPcap API-compatible Mode\"<b> option"
.format('https://nmap.org/npcap/dist/npcap-0.9986.exe'))
msg.setStandardButtons(QMessageBox.Ok)
msg.show()
sys.exit(app.exec_())
+171
View File
@@ -0,0 +1,171 @@
from ..utils import assets
from ..utils import names
from ..utils import async_request
from ..utils import weapon
from PIL import Image, ImageQt
from PySide2 import QtCore
from PySide2 import QtGui
from PySide2.QtCore import Qt
from PySide2.QtGui import QStandardItem
from PySide2.QtGui import QStandardItemModel
from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QComboBox
from PySide2.QtWidgets import QHBoxLayout
from PySide2.QtWidgets import QLabel
from PySide2.QtWidgets import QListView
from PySide2.QtWidgets import QMessageBox
from PySide2.QtWidgets import QProgressBar
from PySide2.QtWidgets import QPushButton
from PySide2.QtWidgets import QVBoxLayout
from io import BytesIO
import collections
import functools
import re
Style = collections.namedtuple('Style', 'bg')
enchant_re = re.compile(r"(.*)@(\d+)")
def map_name(name):
match = enchant_re.match(name)
if match:
return names.map_name(match[1])
return names.map_name(name)
def player_style(items):
weapon_type = weapon.get_weapon_type(items)
if weapon_type == weapon.WeaponType.Arcane:
return Style(bg='#f032e6')
elif weapon_type == weapon.WeaponType.Axe:
return Style(bg='#800000')
elif weapon_type == weapon.WeaponType.Bow:
return Style(bg='#469990')
elif weapon_type == weapon.WeaponType.Crossbow:
return Style(bg='#000075')
elif weapon_type == weapon.WeaponType.Curse:
return Style(bg='#911eb4')
elif weapon_type == weapon.WeaponType.Dagger:
return Style(bg='#4d5f20')
elif weapon_type == weapon.WeaponType.Fire:
return Style(bg='#e6194B')
elif weapon_type == weapon.WeaponType.Frost:
return Style(bg='#4363d8')
elif weapon_type == weapon.WeaponType.Hammer:
return Style(bg='#9A6324')
elif weapon_type == weapon.WeaponType.Holy:
return Style(bg='#42d4f4')
elif weapon_type == weapon.WeaponType.Mace:
return Style(bg='#808000')
elif weapon_type == weapon.WeaponType.Nature:
return Style(bg='#3cb44b')
elif weapon_type == weapon.WeaponType.Quarterstaff:
return Style(bg='#f58231')
elif weapon_type == weapon.WeaponType.Spear:
return Style(bg='#a9a9a9')
elif weapon_type == weapon.WeaponType.Sword:
return Style(bg='#b59d00')
else:
return Style(bg='#42413c')
# @functools.lru_cache(maxsize=None)
def player_icon(weapon):
url = f'https://albiononline2d.ams3.cdn.digitaloceanspaces.com/thumbnails/orig/{weapon}'
try:
r = async_request.get(url)
img = Image.open(BytesIO(r.content))
img_qt = ImageQt.ImageQt(img)
pix = QtGui.QPixmap.fromImage(img_qt)
return QtGui.QIcon(pix)
except Exception:
return None
class DmgList(QListView):
class DmgItem(QtGui.QStandardItem):
def __init__(self, player, parent):
QtGui.QStandardItem .__init__(self)
self.parent = parent
self.player = player
self.update(player)
self.setTextAlignment(
QtCore.Qt.AlignmentFlag.AlignHCenter | QtCore.Qt.AlignmentFlag.AlignVCenter)
def update(self, player):
self.player = player
self.setText("{} {} ({}, {}%)".format(
self.player.name, self.player.damage, self.player.dps, self.player.percentage
))
self.refresh()
def refresh(self):
value = round(self.player.damage / self.player.best_damage, 2)
QRectF = QtCore.QRectF(self.parent.rect())
gradient = QtGui.QLinearGradient(
QRectF.topLeft(), QRectF.topRight())
gradient.setColorAt(value-0.001 if value > 0 else 0,
QtGui.QColor(player_style(self.player.items).bg))
gradient.setColorAt(value, QtGui.QColor('#000000'))
gradient.setColorAt(value+0.001 if value <
1 else 1, QtGui.QColor('#000000'))
brush = QtGui.QBrush(gradient)
self.setBackground(brush)
icon = player_icon(self.player.items['weapon'])
self.setToolTip('\n'.join(
[f'{k}: {map_name(v)}' for (k, v) in self.player.items.items() if v]))
if icon:
self.setIcon(icon)
class SortProxyModel(QtCore.QSortFilterProxyModel):
def lessThan(self, left, right):
l = self.sourceModel().item(left.row())
r = self.sourceModel().item(right.row())
return l.player.percentage < r.player.percentage
class DmgItemModel(QStandardItemModel):
def __init__(self, view):
QStandardItemModel .__init__(self, view)
def __init__(self):
QListView .__init__(self)
self.setIconSize(QtCore.QSize(20, 20))
self.model = self.DmgItemModel(self)
self.proxy = self.SortProxyModel()
self.proxy.setSourceModel(self.model)
self.setModel(self.proxy)
def update(self, players):
if not players:
self.model.clear()
return
visible_names = []
for player in players:
items = (self.model.item(i) for i in range(self.model.rowCount()))
found = next(
(i for i in items if i.player.name == player.name), None)
if found:
found.update(player)
else:
self.model.appendRow(self.DmgItem(player, self))
visible_names.append(player.name)
for i in range(self.model.rowCount()):
item = self.model.item(i)
if hasattr(item, 'player') and hasattr(item.player, 'name') and item.player.name not in visible_names:
self.model.removeRow(i)
self.proxy.sort(0, QtCore.Qt.DescendingOrder)
+174
View File
@@ -0,0 +1,174 @@
import sys
import functools
import datetime
from PySide2.QtCore import QTimer
from PySide2.QtCore import Qt
from PySide2.QtWidgets import QHBoxLayout
from PySide2.QtWidgets import QPushButton
from PySide2.QtWidgets import QVBoxLayout
from PySide2.QtWidgets import QWidget
from PySide2.QtWidgets import QLabel
from PySide2.QtWidgets import QComboBox
from PySide2 import QtGui
from PySide2 import QtCore
from .dmg_list import DmgList
from . import about
from .. import engine
from ..utils import assets
from ..utils.config import config
class Mode:
DMG_CURRENT_ZONE = 'Stats (dmg): Current zone'
DMG_OVERALL = 'Stats (dmg): Overall'
DMG_LAST_FIGHT = 'Stats (dmg): Last fight'
CURRENT_ZONE = 'Stats (all): Current zone'
OVERALL = 'Stats (all): Overall'
LAST_FIGHT = 'Stats (all): Last fight'
class InteractiveBar(QWidget):
def __init__(self, table, clipboard):
QWidget.__init__(self)
self.mode = ModeWidget()
self.table = table
self.layout = QHBoxLayout()
self.about = about.About()
self.fame_per_hour = 0.0
self.clipboard = clipboard
self.layout.addWidget(self.mode)
self.copy_button = QPushButton(self)
self.copy_button.setIcon(QtGui.QIcon(assets.path('copy.png')))
self.copy_button.setToolTip("Copy to clipboard")
self.layout.addWidget(self.copy_button)
self.copy_button.clicked.connect(self.copy)
self.reset_button = QPushButton()
self.reset_button.setIcon(QtGui.QIcon(assets.path('reset.png')))
self.reset_button.setToolTip("Reset")
self.layout.addWidget(self.reset_button)
self.reset_button.clicked.connect(self.reset)
self.about_button = QPushButton(self)
self.about_button.setIcon(QtGui.QIcon(assets.path('about.png')))
self.about_button.setToolTip("About")
self.layout.addWidget(self.about_button)
self.about_button.clicked.connect(self.about.show)
if config()['window']['frameless']:
self.close_button = QPushButton(self)
self.close_button.setIcon(QtGui.QIcon(assets.path('close.png')))
self.close_button.setToolTip("Close")
self.layout.addWidget(self.close_button)
self.close_button.clicked.connect(self.close)
self.setLayout(self.layout)
def copy(self):
model = self.table.model
items = sorted(
[model.item(i).player for i in range(model.rowCount())],
key=lambda i: i.damage,
reverse=True)
clip = "{}, FPH: {}\nDMG: \n".format(
self.mode.currentText(), self.fame_per_hour)
for index, i in enumerate(items[:3]):
clip += '{}. {}-{}/{}-{}%'.format(index+1,
i.name, i.damage, i.dps, i.percentage)
clip += "\n"
clip += "(AOStats https://git.io/JeBD1)"
self.clipboard.clear(mode=self.clipboard.Clipboard)
self.clipboard.setText(clip, mode=self.clipboard.Clipboard)
def set_fame_per_hour(self, fpm):
self.fame_per_hour = fpm
def reset(self):
reset = {
Mode.DMG_CURRENT_ZONE: engine.reset_zone_stats,
Mode.DMG_LAST_FIGHT: engine.reset_last_fight_stats,
Mode.DMG_OVERALL: engine.reset_stats,
Mode.CURRENT_ZONE: engine.reset_zone_stats,
Mode.LAST_FIGHT: engine.reset_last_fight_stats,
Mode.OVERALL: engine.reset_stats,
}
reset[self.mode.currentText()]()
def close(self):
sys.exit(0)
class ModeWidget(QComboBox):
def __init__(self):
QComboBox.__init__(self)
self.addItem(Mode.DMG_CURRENT_ZONE)
self.addItem(Mode.DMG_OVERALL)
self.addItem(Mode.DMG_LAST_FIGHT)
self.addItem(Mode.CURRENT_ZONE)
self.addItem(Mode.OVERALL)
self.addItem(Mode.LAST_FIGHT)
class MainWidget(QWidget):
def __init__(self, clipboard):
QWidget.__init__(self)
self.mouse_pos = None
self.table = DmgList()
self.fame_label = QLabel()
self.fame_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
self.bar = InteractiveBar(self.table, clipboard)
self.layout = QVBoxLayout()
self.layout.addWidget(self.bar)
self.layout.addWidget(self.fame_label)
self.layout.addWidget(self.table)
self.setLayout(self.layout)
self.refresh()
timer = QTimer(self)
timer.timeout.connect(self.refresh)
timer.start(500)
def refresh(self):
damage_session, fame_stat, elapsed = self.session()
self.table.update(damage_session)
self.bar.set_fame_per_hour(fame_stat.fame_per_hour)
self.fame_label.setText("<b>{}</b> | Fame <b>{}</b> | FPH <b>{}</b>".format(
datetime.timedelta(seconds=elapsed), fame_stat.fame, fame_stat.fame_per_hour))
def mousePressEvent(self, event):
self.mouse_pos = event.pos()
def mouseMoveEvent(self, event):
if self.bar.geometry().contains(event.pos()):
return
if not self.mouse_pos:
return
if event.buttons() & Qt.LeftButton:
diff = event.pos() - self.mouse_pos
newpos = self.pos() + diff
self.move(newpos)
def session(self):
sessions = {
Mode.DMG_CURRENT_ZONE: functools.partial(engine.zone_stats, with_damage=True),
Mode.DMG_LAST_FIGHT: functools.partial(engine.last_fight_stats, with_damage=True),
Mode.DMG_OVERALL: functools.partial(engine.overall_stats, with_damage=True),
Mode.CURRENT_ZONE: engine.zone_stats,
Mode.LAST_FIGHT: engine.last_fight_stats,
Mode.OVERALL: engine.overall_stats
}
return sessions[self.bar.mode.currentText()]()
+24
View File
@@ -0,0 +1,24 @@
from ..utils.config import config
cfg = config()
font_size = cfg['window']['font-size']
style = """
QWidget {
font-size: %s;
background-color: black;
color: white;
}
QListView {
min-height: 100px;
}
QListView::item:selected:active {
background-color: black;
}
QListView::item:selected {
background-color: black;
}
""" % (font_size)
View File
+125
View File
@@ -0,0 +1,125 @@
# Example output
# 'player': 'Cursed',
# 'damage': 1100.0,
# 'time_in_combat': 12.0,
# 'dps': 222,
# 'items': {
# 'weapon': 'T5_MAIN_CURSEDSTAFF@2'
# }
from datetime import datetime
class Player:
class CombatTime:
def __init__(self):
self.entered_combat = None
self.time_in_combat = 0.0
class CombatState:
InCombat = 1
OutOfCombat = 2
def __init__(self, name):
self.name = name
self.damage_done = 0.0
self.items = {'weapon': None}
self.combat_time = self.CombatTime()
self.combat_state = self.CombatState.OutOfCombat
@staticmethod
def from_other(other):
Player(other.name)
def register_items(self, value):
self.items = value
def register_damage_done(self, value):
if self.combat_state == self.CombatState.OutOfCombat:
return
self.damage_done += value
def enter_combat(self):
self.combat_time.entered_combat = datetime.now()
self.combat_state = self.CombatState.InCombat
def leave_combat(self):
if self.combat_time.entered_combat:
self.combat_time.time_in_combat += _time_delta(self.combat_time.entered_combat)
self.combat_state = self.CombatState.OutOfCombat
@property
def time_in_combat(self):
if self.combat_state == self.CombatState.InCombat:
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
@property
def dps(self):
if self.time_in_combat == 0.0:
return 0.0
return (self.damage_done / self.time_in_combat) * 1000.0
def stats(self):
return {
'player': self.name,
'damage': self.damage_done,
'time_in_combat': self.time_in_combat,
'dps': self.dps,
'items': self.items}
class DamageStats:
def __init__(self, players=None):
if not players:
players = {}
self.players = players
@staticmethod
def from_other(other):
DamageStats({k: Player.from_other(v)} for k, v in other.players)
def add_player(self, player_id, name):
if player_id not in self.players:
self.players[player_id] = Player(name)
def add_items(self, player_id, items):
self.players[player_id].register_items(items)
def enter_combat(self, player_id):
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):
return [player.stats() for player in self.players.values()]
def combined_stats(stats_list):
combined = {}
for stats in stats_list:
if stats['player'] in combined:
current = combined[stats['player']]
current['damage'] += stats['damage']
current['time_in_combat'] += stats['time_in_combat']
current['dps'] += stats['dps']
current['items'] = stats['items']
else:
combined[stats['player']] = stats
return [s for s in combined.values()]
def _time_delta(time):
delta = datetime.now() - time
return (delta.seconds * 1000.0 + delta.microseconds / 1000.0)
+2
View File
@@ -0,0 +1,2 @@
from . import number
from . import config
+6
View File
@@ -0,0 +1,6 @@
import os
assets_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'assets')
def path(file):
return os.path.join(assets_path, file)
+43
View File
@@ -0,0 +1,43 @@
import threading
import queue
import requests
import collections
Item = collections.namedtuple('Item', 'key value')
_queue = queue.Queue()
_requests = {}
_requests_threads = {}
def update_loop():
while True:
item = _queue.get()
_requests[item.key] = item.value
_requests_threads[item.key].join()
del _requests_threads[item.key]
_update_thread = threading.Thread(target=update_loop, daemon=True)
_update_thread.start()
def _async_req(url):
req = requests.get(url)
_queue.put(Item(key=url, value=req))
def get(url):
if url in _requests:
return _requests[url]
if url in _requests_threads:
return None
rt = threading.Thread(target=_async_req, args=(url,))
_requests_threads[url] = rt
rt.start()
return None
+48
View File
@@ -0,0 +1,48 @@
import os
import sys
import toml
CFG_VERSION = '0.6'
default = """
[window]
width = 300
height = 220
font-size = '10px'
opacity = 0.8
frameless = true
always_on_top = true
[app]
[config]
# do not change
version = '%s'
""" % (CFG_VERSION)
_script_path = sys.argv[0] # pyinstaller creates tmpdir for python files, thus this is the way to get executable path
_config = None
def config():
global _script_path
global _config
if _config:
return _config
conf_file = os.path.join(os.path.dirname(
_script_path), 'albion-online-stats.cfg')
try:
with open(conf_file, "r") as cfg_file:
cfg = toml.load(cfg_file)
if cfg['config']['version'] != CFG_VERSION:
raise Exception('Version changed')
return cfg
except(Exception) as e:
with open(conf_file, "w") as cfg_file:
cfg_file.write(default)
return toml.loads(default)
return {}
+15
View File
@@ -0,0 +1,15 @@
import json
from . import assets
_mappings = None
def map_name(name):
global _mappings
if not _mappings:
with open(assets.path('localization.json')) as m:
_mappings = json.loads(m.read())
return _mappings[name] if name in _mappings else name
+25
View File
@@ -0,0 +1,25 @@
class Number:
def __init__(self, number):
self.number = number
def __eq__(self, other):
return self.number == other
def __lt__(self, other):
if isinstance(other, Number):
return self.number < other.number
return self.number < other
def __truediv__(self, other):
if isinstance(other, Number):
return self.number / other.number if other.number else other.number
return self.number / other if other else other
def __str__(self):
if self.number / 1000 < 1:
return "{0:.2f}".format(self.number)
elif self.number / 1000000 >= 1:
return "{0:.2f}M".format(self.number / 1000000)
elif self.number / 1000 >= 1:
return "{0:.2f}K".format(self.number / 1000)
return "{0:.2f}".format(self.number)
+17
View File
@@ -0,0 +1,17 @@
import os
import requests
_version = "0.8.1"
latest_url = "https://github.com/mazurwiktor/albion-online-stats/releases/latest"
def latest_version():
req = requests.get(latest_url)
if req.status_code == 200:
return os.path.basename(req.url)
return None
def current_version():
return _version
+68
View File
@@ -0,0 +1,68 @@
import json
from . import assets
class WeaponType:
Arcane = 'arcanestaff'
Axe = 'axe'
Bow = 'bow'
Crossbow = 'crossbow'
Curse = 'cursestaff'
Dagger = 'dagger'
Fire = 'firestaff'
Frost = 'froststaff'
Hammer = 'hammer'
Holy = 'holystaff'
Mace = 'mace'
Nature = 'naturestaff'
Quarterstaff = 'quarterstaff'
Spear = 'spear'
Sword = 'sword'
_mappings = None
def map_weapon(weapon):
global _mappings
if not _mappings:
with open(assets.path('item_category_map.json')) as m:
_mappings = json.loads(m.read())
return _mappings[weapon] if weapon in _mappings else None
def get_weapon_type(items):
weapon = map_weapon(items['weapon'])
if weapon == WeaponType.Arcane:
return WeaponType.Arcane
elif weapon == WeaponType.Axe:
return WeaponType.Axe
elif weapon == WeaponType.Bow:
return WeaponType.Bow
elif weapon == WeaponType.Crossbow:
return WeaponType.Crossbow
elif weapon == WeaponType.Curse:
return WeaponType.Curse
elif weapon == WeaponType.Dagger:
return WeaponType.Dagger
elif weapon == WeaponType.Fire:
return WeaponType.Fire
elif weapon == WeaponType.Frost:
return WeaponType.Frost
elif weapon == WeaponType.Hammer:
return WeaponType.Hammer
elif weapon == WeaponType.Holy:
return WeaponType.Holy
elif weapon == WeaponType.Mace:
return WeaponType.Mace
elif weapon == WeaponType.Nature:
return WeaponType.Nature
elif weapon == WeaponType.Quarterstaff:
return WeaponType.Quarterstaff
elif weapon == WeaponType.Spear:
return WeaponType.Spear
elif weapon == WeaponType.Sword:
return WeaponType.Sword
else:
return None
+3
View File
@@ -0,0 +1,3 @@
import sys
sys.path.append('../src')
+35
View File
@@ -0,0 +1,35 @@
import pytest
from src.number import Number
def test_number_equality():
n = 10
number = Number(10)
assert number == n
other = Number(n)
assert number == other
def test_less_comparator():
assert Number(10) < Number(20)
assert Number(10) < 20
def test_div():
assert Number(10) / Number(10) == 1
assert Number(10) / 10 == 1
@pytest.mark.parametrize('num,text', [
(10, '10.00'),
(100, '100.00'),
(100.01, '100.01'),
(100.01123432123, '100.01'),
(1000, '1.00K'),
(10000, '10.00K'),
(120010.12332, '120.01K'),
(100000, '100.00K'),
(5000000, '5.00M')
])
def test_str_repr(num, text):
assert str(Number(num)) == text
+24
View File
@@ -0,0 +1,24 @@
[tox]
skipsdist=True
envlist = python3
[testenv]
deps =
pytest
pyside2~=5.13
pyinstaller
toml~=0.10
requests~=2.22
Pillow~=6.2
[testenv:flake8]
deps =
flake8==3.7.9
flake8-import-order==0.18.1
commands =
flake8 src
[testenv:ut]
commands =
python -m pytest tests