removed backend

This commit is contained in:
Wiktor Mazur
2020-05-25 17:02:41 +02:00
parent c867075b2d
commit a2f25750e2
95 changed files with 3 additions and 18539 deletions
+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: 57 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

+144
View File
@@ -0,0 +1,144 @@
try:
import aostats # type: ignore
except:
class aostats: # type: ignore
@staticmethod
def initialize():
return InitializationResult.NetworkInterfaceListMissing
@staticmethod
def subscribe(_):
pass
from .environment import TEST_ENV_ENABLED
from . import environment
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}}},
]
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 time
sequence = {}
sequence[environment.TestType.Simple] = [
{'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'),
*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),
*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}},
{'name': 'ZoneChange'},
*add_player(1, 'Cursed', 'T5_MAIN_CURSEDSTAFF@2'),
*deal_damage(1, 'Cursed', 80.0),
{'name': 'ZoneChange'},
]
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}},
]
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:
time.sleep(v['sleep'])
else:
callback(v)
thread = threading.Thread(target=run_sequence, daemon=True)
thread.start()
View File
+17
View File
@@ -0,0 +1,17 @@
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'
EvNameUpdateParty : str = 'UpdateParty'
EvKeyName : str = 'name'
EvKeyValue : str = 'value'
EvKeySource : str = 'source'
EvKeyTarget : str = 'target'
EvKeyId : str = 'id'
EvKeyPlayerNames : str = 'player_names'
+208
View File
@@ -0,0 +1,208 @@
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, fame_stats, time_stats, combat_state
from .consts import events as ev_consts
from .event_receiver import VisibilityEventReceiver
from .stats.visibility import Visibility
@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'
@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(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
}
self.last_fight = {
StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
}
self.history = {
StatType.Combat: combat_stats.CombatStats(self.visibility),
StatType.Fame: fame_stats.FameStats(),
StatType.Time: time_stats.TimeStats(),
}
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._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.visibility.receive(event)
def reset(self, stat_type):
if stat_type == VisibilityType.Zone:
for t in (StatType.Combat, StatType.Time, StatType.Fame):
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_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:
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 _construct_new_stats(self, scope: Iterable[str]):
types = (StatType.Combat, StatType.Time, StatType.Fame)
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()
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)
cached_players = () # do not compute values if there is nothing in queue
cached_stat_type = None
cached_combat_stat_type = None
def get_stats(stat_type: str, combat_stat_type: str):
global cached_players, cached_stat_type, cached_combat_stat_type
new_events = False
while not event_queue.empty():
new_events = True
game_stats.register_event(event_queue.get_nowait())
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.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 queue_an_event(event):
event_queue.put(event)
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()
backend_proxy.subscribe(queue_an_event)
return initialization_result
+25
View File
@@ -0,0 +1,25 @@
import os
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.Healing: TestType.Healing
}
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[test_type.lower()]
+91
View File
@@ -0,0 +1,91 @@
import abc
from typing import Dict, List
from .consts import events as consts
class EventReceiver(abc.ABC):
def receive(self, event):
event_name: str = event[consts.EvKeyName]
value: dict = event[consts.EvKeyValue] if consts.EvKeyValue in event else None
self.on_event(event_name, value)
@abc.abstractmethod
def on_event(self, name: str, value: dict):
pass
class VisibilityEventReceiver(EventReceiver):
def on_event(self, event_name: str, value: dict):
if event_name == consts.EvNameMainPlayerAppeared:
self.on_player_appeared(value[consts.EvKeyName])
elif event_name == consts.EvNameUpdateParty:
self.on_visible_players_changed(value[consts.EvKeyPlayerNames])
@abc.abstractmethod
def on_player_appeared(self, main_player_name: str):
pass
@abc.abstractmethod
def on_visible_players_changed(self, visible_players : List[str]):
pass
class FameEventReceiver(EventReceiver):
def on_event(self, event_name: str, value: dict):
if event_name == consts.EvNameUpdateFame:
self.on_fame_update(value[consts.EvKeyValue])
@abc.abstractmethod
def on_fame_update(self, value: float):
pass
class CombatEventReceiver(EventReceiver):
def on_event(self, event_name: str, value: dict):
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.EvKeyTarget], value[consts.EvKeyValue])
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.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, target_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
View File
+109
View File
@@ -0,0 +1,109 @@
import os
import platform
import sys
import requests
from PySide2 import QtCore # type: ignore
from PySide2.QtCore import Qt # type: ignore
from PySide2 import QtGui # type: ignore
from PySide2.QtWidgets import QApplication # type: ignore
from PySide2.QtWidgets import QMessageBox # type: ignore
from PySide2.QtWidgets import QPushButton # type: ignore
from ..engine import InitializationResult
from ..engine import initialize
from ..utils.config import config
from .modules.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 ..utils.assets import path
from ..utils.assets import scripts
sys.path.append(os.path.dirname(os.path.abspath('__file__')))
def fix_npcap():
os.system(scripts('fixnpcap.bat'))
sys.exit(0)
def get_modt(always_on_top):
motd_url = 'https://mazurwiktor.github.io/aostats/motd'
msg = QMessageBox()
msg.setObjectName("Motd")
msg.setWindowTitle("MOTD")
msg.setInformativeText(str(requests.get(motd_url).text))
msg.setStandardButtons(QMessageBox.Ok)
return msg
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('Albion Online Stats')
widget.setWindowIcon(QtGui.QIcon(path('albion-stats-icon.png')))
modt = get_modt(['always_on_top'])
if window_config['always_on_top']:
widget.setWindowFlag(Qt.WindowStaysOnTopHint)
modt.setWindowFlag(Qt.WindowStaysOnTopHint)
if window_config['frameless']:
widget.setWindowFlag(Qt.FramelessWindowHint)
widget.show()
modt.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<br><br>\
In case where npcap is installed try to fix npcap and restart the app"
.format('https://nmap.org/npcap/dist/npcap-0.9990.exe'))
msg.setStandardButtons(QMessageBox.Ok)
button = QPushButton("Fix npcap")
button.clicked.connect(fix_npcap)
msg.addButton(button, QMessageBox.NoRole)
msg.show()
sys.exit(app.exec_())
View File
+30
View File
@@ -0,0 +1,30 @@
from PySide2.QtWidgets import QMessageBox # type: ignore
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)
+143
View File
@@ -0,0 +1,143 @@
import sys
import functools
from PySide2 import QtGui # type: ignore
from PySide2.QtCore import Qt # type: ignore
from PySide2.QtCore import QTimer # type: ignore
from PySide2.QtWidgets import QComboBox # type: ignore
from PySide2.QtWidgets import QHBoxLayout # type: ignore
from PySide2.QtWidgets import QPushButton # type: ignore
from PySide2.QtWidgets import QVBoxLayout # type: ignore
from PySide2.QtWidgets import QWidget # type: ignore
from ... import engine
from ...utils import assets
from ...utils.config import config
from .view_type import ViewType
from .views import ModeBasedListView
from .views import StatsType
from . import about
class AboutButton(QPushButton):
def __init__(self):
QPushButton.__init__(self)
self.about = about.About()
self.setIcon(QtGui.QIcon(assets.path('about.png')))
self.setToolTip("About")
self.clicked.connect(self.about.show)
class CloseButton(QPushButton):
def __init__(self, is_visible):
QPushButton.__init__(self)
self.setIcon(QtGui.QIcon(assets.path('close.png')))
self.setToolTip("Close")
self.clicked.connect(self.close)
if not is_visible:
self.hide()
def close(self):
sys.exit(0)
class ViewTypeWidget(QComboBox):
def __init__(self):
QComboBox.__init__(self)
self.addItem(ViewType.DMG)
self.addItem(ViewType.HEALING_DONE)
def get_view_type(self):
return self.currentText()
class TopBar(QWidget):
def __init__(self):
QWidget.__init__(self)
self.view_type = ViewTypeWidget()
self.layout = QHBoxLayout()
self.layout.setSpacing(0)
self.layout.setMargin(0)
self.layout.addWidget(self.view_type)
self.about_button = AboutButton()
self.layout.addWidget(self.about_button)
self.close_button = CloseButton(config()['window']['frameless'])
self.layout.addWidget(self.close_button)
self.setLayout(self.layout)
class MainWidget(QWidget):
def __init__(self, clipboard):
QWidget.__init__(self)
self.mouse_pos = None
self.layout = QVBoxLayout()
self.top_bar = TopBar()
self.layout.addWidget(self.top_bar)
self.view = ModeBasedListView(clipboard)
self.layout.addWidget(self.view)
self.setLayout(self.layout)
self.refresh()
timer = QTimer(self)
timer.timeout.connect(self.refresh)
timer.start(500)
def refresh(self):
player_list_items, fame_stat, elapsed = self.damage_stats()
self.view.update(
self.top_bar.view_type.get_view_type(),
elapsed,
fame_stat.fame,
fame_stat.fame_per_hour,
player_list_items
)
def mousePressEvent(self, event):
self.mouse_pos = event.pos()
def mouseMoveEvent(self, event):
invalid_regions = (
self.top_bar.geometry(),
self.view.geometry(),
)
if any(region.contains(event.pos()) for region in invalid_regions):
return
if not self.mouse_pos:
return
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
self.move(newpos)
def damage_stats(self):
stats = {
ViewType.DMG: {
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),
}
}
return stats[self.top_bar.view_type.get_view_type()][self.view.get_mode()]()
+3
View File
@@ -0,0 +1,3 @@
class ViewType:
DMG: str = 'Stats (damage done)'
HEALING_DONE: str = 'Stats (healing done)'
+2
View File
@@ -0,0 +1,2 @@
from .mode_based_list_view import ModeBasedListView
from .stats_type import StatsType
+40
View File
@@ -0,0 +1,40 @@
from PySide2.QtWidgets import QPushButton # type: ignore
from PySide2 import QtGui # type: ignore
from ....utils import assets
from ....stats.list_item import PlayerListItem
from .stats_type import StatsType
class CopyButton(QPushButton):
def __init__(self, clipboard):
QPushButton.__init__(self)
self.clipboard = clipboard
self.prefix = '<< INITIAL PREFIX >>'
self.players: PlayerListItem = []
self.mode = StatsType.ZONE
self.fame = 0.0
self.clicked.connect(self.copy)
self.setIcon(QtGui.QIcon(assets.path('copy.png')))
self.setToolTip("Copy to clipboard")
def copy(self):
clip = "{}: {}, FPH: {}\n".format(
self.prefix, self.mode, self.fame)
for index, i in enumerate(self.players[:3]):
clip += '{}. {}-{}/{}-{}%'.format(index+1,
i.name, i.value, i.value_per_second, 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 update(self, prefix: str, players: PlayerListItem, mode: str, fame: float):
self.prefix = prefix
self.players = players
self.mode = mode
self.fame = fame
@@ -0,0 +1 @@
from .list import ListItemView
+29
View File
@@ -0,0 +1,29 @@
from io import BytesIO
from PIL import Image, ImageQt # type: ignore
from PySide2 import QtGui # type: ignore
from .....utils import async_request
icon_cache = {}
def get_weapon_icon(weapon):
global icon_cache
url = f'https://albiononline2d.ams3.cdn.digitaloceanspaces.com/thumbnails/orig/{weapon}'
if weapon in icon_cache:
return icon_cache[weapon]
try:
r = async_request.get(url)
img = Image.open(BytesIO(r.content))
img_qt = ImageQt.ImageQt(img)
pix = QtGui.QPixmap.fromImage(img_qt)
icon_cache[weapon] = QtGui.QIcon(pix)
return icon_cache[weapon]
except Exception:
return None
+162
View File
@@ -0,0 +1,162 @@
import collections
import functools
import re
from typing import List
from PySide2 import QtCore # type: ignore
from PySide2 import QtGui # type: ignore
from PySide2.QtCore import Qt # type: ignore
from PySide2.QtGui import QStandardItem # type: ignore
from PySide2.QtGui import QStandardItemModel # type: ignore
from PySide2.QtWidgets import QApplication # type: ignore
from PySide2.QtWidgets import QComboBox # type: ignore
from PySide2.QtWidgets import QHBoxLayout # type: ignore
from PySide2.QtWidgets import QLabel # type: ignore
from PySide2.QtWidgets import QListView # type: ignore
from PySide2.QtWidgets import QMessageBox # type: ignore
from PySide2.QtWidgets import QProgressBar # type: ignore
from PySide2.QtWidgets import QPushButton # type: ignore
from PySide2.QtWidgets import QVBoxLayout # type: ignore
from .....stats.list_item import PlayerListItem
from .....utils import assets
from .....utils import names
from .....utils import weapon
from .icon import get_weapon_icon as player_icon
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')
class ListItemView(QListView):
class Item(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.value, self.player.value_per_second, self.player.percentage
))
self.refresh()
def refresh(self):
value = round(self.player.value / self.player.best_value, 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 ItemModel(QStandardItemModel):
def __init__(self, view):
QStandardItemModel .__init__(self, view)
def __init__(self):
QListView .__init__(self)
self.setIconSize(QtCore.QSize(20, 20))
self.model = self.ItemModel(self)
self.proxy = self.SortProxyModel()
self.proxy.setSourceModel(self.model)
self.setModel(self.proxy)
def update(self, players: List[PlayerListItem]):
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.Item(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)
def get_player_list_items(self) -> List[PlayerListItem]:
return sorted(
[self.model.item(i).player for i in range(self.model.rowCount())],
key=lambda i: i.value,
reverse=True)
@@ -0,0 +1,75 @@
# from PySide2.QtCore import QTimer
# from PySide2.QtCore import Qt
from typing import Callable
from PySide2.QtWidgets import QHBoxLayout # type: ignore
from PySide2.QtWidgets import QVBoxLayout # type: ignore
from PySide2.QtWidgets import QComboBox # type: ignore
from PySide2.QtWidgets import QWidget # type: ignore
from ....stats.list_item import PlayerListItem
from .list_view import ListItemView
from .stats_type import StatsType
from .player_stats import PlayerStats
from .copy_button import CopyButton
from .reset_button import ResetButton
class ModeWidget(QComboBox):
def __init__(self):
QComboBox.__init__(self)
self.addItem(StatsType.OVERALL)
self.addItem(StatsType.ZONE)
self.addItem(StatsType.LAST_FIGHT)
def get_mode(self):
return self.currentText()
class SessionBar(QWidget):
def __init__(self, clipboard):
QWidget.__init__(self)
self.layout = QHBoxLayout()
self.reset_button = ResetButton()
self.layout.addWidget(self.reset_button)
self.copy_button = CopyButton(clipboard)
self.layout.addWidget(self.copy_button)
self.mode = ModeWidget()
self.layout.addWidget(self.mode)
self.player_stats = PlayerStats()
self.layout.addWidget(self.player_stats)
self.setLayout(self.layout)
def update(self):
self.reset_button.update(self.mode.get_mode())
class ModeBasedListView(QWidget):
def __init__(self, clipboard):
QWidget.__init__(self)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setMargin(0)
self.session_bar = SessionBar(clipboard)
self.layout.addWidget(self.session_bar)
self.list_view = ListItemView()
self.layout.addWidget(self.list_view)
self.setLayout(self.layout)
def update(self, prefix, elapsed, fame, fame_per_hour, players: PlayerListItem):
self.session_bar.player_stats.update(elapsed, fame, fame_per_hour)
self.session_bar.copy_button.update(prefix, self.list_view.get_player_list_items(), self.session_bar.mode.get_mode(), fame)
self.list_view.update(players)
self.session_bar.update()
def get_mode(self) -> str:
return self.session_bar.mode.get_mode()
View File
+23
View File
@@ -0,0 +1,23 @@
import datetime
from PySide2.QtWidgets import QLabel # type: ignore
from PySide2 import QtGui # type: ignore
from PySide2 import QtCore # type: ignore
from src.utils import assets, number
from src.stats.list_item import PlayerListItem
from src import engine
class PlayerStats(QLabel):
def __init__(self):
QLabel.__init__(self)
self.update(0, number.Number(0.0), number.Number(0.0))
def update(self, elapsed, fame, fame_per_hour):
if engine.is_ready():
self.setText("<b>{}</b> | Fame <b>{}</b> | FPH <b>{}</b>".format(
datetime.timedelta(seconds=elapsed), fame, fame_per_hour))
else:
self.setText("Not ready: waiting for zone change")
+33
View File
@@ -0,0 +1,33 @@
from typing import Callable
from PySide2.QtWidgets import QPushButton # type: ignore
from PySide2 import QtGui # type: ignore
from ....utils import assets
from ....stats.list_item import PlayerListItem
from .... import engine
from .stats_type import StatsType
class ResetButton(QPushButton):
def __init__(self):
QPushButton.__init__(self)
self.stat_type: str = StatsType.ZONE
self.setIcon(QtGui.QIcon(assets.path('reset.png')))
self.setToolTip("Reset")
self.clicked.connect(self.reset)
def reset(self):
reset = {
StatsType.ZONE: engine.reset_zone_stats,
StatsType.LAST_FIGHT: engine.reset_last_fight_stats,
StatsType.OVERALL: engine.reset_stats,
}
reset[self.stat_type]()
def update(self, stat_type: str):
self.stat_type = stat_type
+4
View File
@@ -0,0 +1,4 @@
class StatsType:
ZONE = 'Zone'
OVERALL = 'Overall'
LAST_FIGHT = 'Fight'
+30
View File
@@ -0,0 +1,30 @@
from ..utils.config import config
cfg = config()
font_size = cfg['window']['font-size']
style = """
QWidget {
font-size: %s;
background-color: black;
color: white;
}
#Motd, #Motd > * {
background-color: none;
color: none;
font-size: auto;
}
QListView {
min-height: 100px;
}
QListView::item:selected:active {
background-color: black;
}
QListView::item:selected {
background-color: black;
}
""" % (font_size)
+6
View File
@@ -0,0 +1,6 @@
@echo off
if not "%1"=="am_admin" (powershell start -verb runas '%0' am_admin & exit /b)
net stop npcap
net start npcap
pause
View File
+3
View File
@@ -0,0 +1,3 @@
class CombatState:
InCombat = 1
OutOfCombat = 2
+217
View File
@@ -0,0 +1,217 @@
# Example output
# 'player': 'Cursed',
# 'damage': 1100.0,
# 'time_in_combat': 12.0,
# 'dps': 222,
# 'items': {
# 'weapon': 'T5_MAIN_CURSEDSTAFF@2'
# }
from dataclasses import field
from dataclasses import dataclass
from typing import Optional, List, Callable, Iterable
from . import time_utils
from ..event_receiver import CombatEventReceiver, VisibilityEventReceiver
from .statistics import Stats
from .list_item import PlayerListItem, StandalonePlayerListItem, to_player_list_items
from .visibility import Visibility
from .combat_state import CombatState
@dataclass
class CombatTime:
entered_combat: Optional[float] = None
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
active: bool = False
def activate(self):
self.active = True
def is_active(self) -> bool:
return self.active
def has_stats(self) -> bool:
return bool(self.damage_done or self.healing_done)
@staticmethod
def new(self):
raise Exception("Should never happen")
@staticmethod
def from_other(other):
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
self.items = other.items
self.active = other.active or self.active
def register_items(self, value):
self.items = value
def register_damage_done(self, value):
if self.combat_state == CombatState.OutOfCombat:
return
self.damage_done += value
self.activate()
def register_healing_done(self, value):
if self.party.combat_state() == CombatState.OutOfCombat:
return
self.healing_done += value
self.activate()
def enter_combat(self):
self.combat_time.entered_combat = time_utils.now()
self.combat_state = CombatState.InCombat
def leave_combat(self):
if self.combat_time.entered_combat:
self.combat_time.time_in_combat += time_utils.delta(
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:
if 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
@property
def dps(self):
if self.time_in_combat == 0.0:
return 0.0
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, visibility, players=None):
self.visibility = visibility
self.party = Party(self.visible_players)
if not players:
players = {}
self.players = players
@staticmethod
def new(self):
raise Exception("Should never happen")
@staticmethod
def from_other(other):
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():
if id in self.players:
self.players[id].update(player)
else:
self.players[id] = Player.from_other(player)
self.players[id].update(player)
def update_non_idle(self, other):
self.update(other)
self.players = dict(filter(lambda elem: elem[1].has_stats(), self.players.items()))
for player in self.players.values():
player.activate()
def combined(self, other):
stats = CombatStats(self.visibility)
stats.update(self)
stats.update(other)
return stats
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 player.is_active() and 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.party)
self.players[id].activate()
def on_damage_done(self, id: int, damage: float):
self.players[id].register_damage_done(damage)
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()
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)
+29
View File
@@ -0,0 +1,29 @@
from dataclasses import dataclass
from ..event_receiver import FameEventReceiver
from .statistics import Stats
@dataclass
class FameStats(FameEventReceiver, Stats):
fame: float = 0.0
@classmethod
def new(self):
return FameStats()
@classmethod
def from_other(other: Stats): # type: ignore
return FameStats(fame=other.fame) # type: ignore
def update(self, other: Stats): # type: ignore
self.fame += other.fame # type: ignore
def on_fame_update(self, value: float):
self.fame += value
def stats(self):
return {
'fame': self.fame,
'fame_per_hour': 0.0 # TODO: remove, added because backward compatibility
}
+50
View File
@@ -0,0 +1,50 @@
from dataclasses import dataclass
from typing import List
from ..utils.number import Number
from .combat_state import CombatState
@dataclass
class StandalonePlayerListItem:
name: str
items: dict
value: float
value_per_second: float
combat_state: int
@dataclass
class PlayerListItem:
name: str
items: dict
value: Number
value_per_second: Number
best_value: Number
percentage: Number
combat_state: int
def to_player_list_items(standalone_list: List[StandalonePlayerListItem]) -> List[PlayerListItem]:
best = 0.0
combined = 0.0
for item in standalone_list:
if item.value > best:
best = item.value
combined += item.value
combined_list: List[PlayerListItem] = []
for item in standalone_list:
percentage = item.value / combined * 100 if item.value else 0.0
combined_list.append(PlayerListItem(
item.name,
item.items,
Number(item.value),
Number(item.value_per_second),
Number(best),
Number(percentage),
item.combat_state
))
return combined_list
+22
View File
@@ -0,0 +1,22 @@
import abc
class Stats(abc.ABC):
@abc.abstractmethod
def new(self):
pass
@abc.abstractclassmethod
def from_other(other):
pass
@abc.abstractmethod
def update(self, other):
pass
def combined(self, other):
stats = self.new()
stats.update(self)
stats.update(other)
return stats
+27
View File
@@ -0,0 +1,27 @@
from dataclasses import field
from dataclasses import dataclass
from . import time_utils
from .statistics import Stats
@dataclass
class TimeStats(Stats):
time: float = field(default_factory=lambda: time_utils.now())
@classmethod
def new(self):
return TimeStats()
def stats(self):
return {
'seconds_in_game': time_utils.as_seconds(time_utils.delta(self.time))
}
@classmethod
def from_other(other):
return TimeStats(time=other.time)
def update(self, other):
if other.time < self.time:
self.time = other.time
+18
View File
@@ -0,0 +1,18 @@
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_milliseconds(time):
return time * 1000.0
def as_seconds(time):
return int(time / 1000.0)
+45
View File
@@ -0,0 +1,45 @@
import functools
from dataclasses import dataclass, field
from typing import List
import re
from src.utils.config import config
from ..event_receiver import VisibilityEventReceiver
@dataclass
class Visibility(VisibilityEventReceiver):
main_player_name: str = ""
visible_players: List[str] = field(default_factory=lambda: [])
def on_player_appeared(self, main_player_name: str):
self.main_player_name = main_player_name
def on_visible_players_changed(self, visible_players: List[str]):
self.visible_players = visible_players
def test(self, name):
if _is_visible_by_config(): # Note: only for testing purposes
return True
pattern = '|'.join(self.visible_players) + '|{}'.format(
self.main_player_name) if self.visible_players else self.main_player_name
return self.main_player_name and bool(_compile_pattern(pattern).match(name))
@property
def is_main_player_visible(self) -> bool:
return self.main_player_name is not ""
@functools.lru_cache(maxsize=128)
def _is_visible_by_config():
if 'visibility' in config()['app']:
return True
return False
@functools.lru_cache(maxsize=128)
def _compile_pattern(pattern: str):
return re.compile(pattern)
+2
View File
@@ -0,0 +1,2 @@
from . import number
from . import config
+15
View File
@@ -0,0 +1,15 @@
import os
assets_path = os.path.join(os.path.dirname(
os.path.abspath(__file__)), '..', 'assets')
scripts_path = os.path.join(os.path.dirname(
os.path.abspath(__file__)), '..', 'scripts')
def path(file):
return os.path.join(assets_path, file)
def scripts(script_name):
return os.path.join(scripts_path, script_name)
+46
View File
@@ -0,0 +1,46 @@
import threading
import queue
import requests
import collections
Item = collections.namedtuple('Item', 'key value')
_queue : queue.Queue = queue.Queue()
_requests = {}
_requests_threads : dict = {}
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
+54
View File
@@ -0,0 +1,54 @@
import os
import sys
import toml
CFG_VERSION = '0.7'
default = """
[window]
width = 300
height = 220
font-size = '10px'
# Note: do not change!
# options bellow are here only for testing purposes
# SBI politics doesn't allow opacity frameless and always on top applications!
opacity = 1.0
frameless = false
always_on_top = false
[app]
[config]
# do not change
version = '%s'
""" % (CFG_VERSION)
# pyinstaller creates tmpdir for python files, thus this is the way to get executable path
_script_path = sys.argv[0]
_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')
_config = cfg
except(Exception) as _:
with open(conf_file, "w") as cfg_file:
cfg_file.write(default)
_config = toml.loads(default)
return _config
+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.11.2"
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
+71
View File
@@ -0,0 +1,71 @@
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