Compare commits
10 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 887667af07 | |||
| 60137a2de4 | |||
| 85a844208a | |||
| 59a9fa4098 | |||
| 6e78b282a6 | |||
| 774f596c09 | |||
| 3e0ad62cf2 | |||
| 2895be91c4 | |||
| c582677329 | |||
| ac487adf5a |
@@ -0,0 +1 @@
|
||||
3.10
|
||||
@@ -1,2 +1,4 @@
|
||||
include README.md
|
||||
include src/assets/*.png
|
||||
include src/static/*
|
||||
include src/scripts/*
|
||||
@@ -7,6 +7,10 @@
|
||||
|
||||
**Powered by** <a href="https://github.com/mazurwiktor/aoaddons-python"> **pyaoaddons** </a> & <a href="https://github.com/mazurwiktor/albion-online-addons"> **albion online addons** </a>
|
||||
|
||||
> On Linux the app no longer depends on `pyaoaddons`: it ships a pure-Python
|
||||
> Protocol18 decoder and captures packets directly through `AF_PACKET`
|
||||
> (no libpcap needed). `pyaoaddons` is still used on Windows and macOS.
|
||||
|
||||
[](https://discord.gg/3U2rpyV)
|
||||
|
||||
|
||||
@@ -30,15 +34,73 @@ Albion online stats is an extension to MMORPG game - Albion Online. It tracks ne
|
||||
|
||||
## Installation
|
||||
|
||||
1. On windows make sure that WinPcap is installed in your system. [Npcap 0.9983 installer for Windows Vista/2008, 7/2008R2, 8/2012, 8.1/2012R2, 10/2016 (x86 and x64)](https://nmap.org/npcap/dist/npcap-0.9983.exe) **Make sure to install with the "Install Npcap in WinPcap API-compatible Mode"**
|
||||
### Windows
|
||||
|
||||
1. Make sure that WinPcap is installed in your system. [Npcap 0.9983 installer for Windows Vista/2008, 7/2008R2, 8/2012, 8.1/2012R2, 10/2016 (x86 and x64)](https://nmap.org/npcap/dist/npcap-0.9983.exe) **Make sure to install with the "Install Npcap in WinPcap API-compatible Mode"**
|
||||
2. Install python [all platforms installation instructions](https://docs.python.org/3/using/) or via [Microsoft Store](https://www.microsoft.com/en-us/p/python-39/9p7qfqmjrfp7).
|
||||
3. Download latest launcher from https://github.com/mazurwiktor/albion-online-stats/releases/latest (albion-online-stats.bat for windows albion-online-stats.sh for linux and mac)
|
||||
3. Enjoy :)
|
||||
3. Download the latest launcher from https://github.com/mazurwiktor/albion-online-stats/releases/latest (`albion-online-stats.bat`).
|
||||
4. Enjoy :)
|
||||
|
||||
### Linux / macOS
|
||||
|
||||
1. Install python 3 and the `venv` module with your package manager. On macOS also install libpcap:
|
||||
|
||||
```shell
|
||||
# Debian / Ubuntu
|
||||
sudo apt install python3 python3-venv python3-pip
|
||||
# Fedora
|
||||
sudo dnf install python3 python3-pip
|
||||
# Arch
|
||||
sudo pacman -S python
|
||||
# macOS
|
||||
brew install libpcap
|
||||
```
|
||||
|
||||
2. Capturing network traffic requires elevated privileges. Either run the app with `sudo`, or grant the Python interpreter the capabilities it needs:
|
||||
|
||||
```shell
|
||||
sudo setcap cap_net_raw,cap_net_admin=eip "$(readlink -f "$(command -v python3)")"
|
||||
```
|
||||
|
||||
The app can do this for you from the **Fix capture permissions** button in its error dialog.
|
||||
|
||||
3. Download the latest launcher from https://github.com/mazurwiktor/albion-online-stats/releases/latest (`albion-online-stats.sh`), make it executable and run it:
|
||||
|
||||
```shell
|
||||
chmod +x albion-online-stats.sh
|
||||
./albion-online-stats.sh
|
||||
```
|
||||
|
||||
4. Enjoy :)
|
||||
|
||||
> **Note:** on macOS (and Windows) the packet capture backend (`pyaoaddons`) only ships prebuilt wheels for CPython 3.6-3.10. If you use a newer Python, `pyaoaddons` is not installed automatically and the app will report that the backend is missing. Either use Python 3.10 (or older) or build `pyaoaddons` from source (requires a Rust toolchain). This does not affect Linux, where the built-in decoder is used.
|
||||
|
||||
## Configuration
|
||||
|
||||
After first execution the app is going to create default configuration file named `albion-online-stats.cfg`. Feel free to edit it according to your needs.
|
||||
|
||||
## Debugging
|
||||
|
||||
Start the app with `--verbose` (or set `AOSTATS_VERBOSE=1`) to enable detailed logging of the app and the packet capture backend:
|
||||
|
||||
```shell
|
||||
aostats --verbose
|
||||
```
|
||||
|
||||
This prints the backend initialization result, the capture-permission probe, and every received game event to the terminal. On Windows/macOS the capture backend also writes its own log to `aoaddons.log` in the current working directory.
|
||||
|
||||
On Linux the app uses its own `AF_PACKET` capture and Protocol18 decoder; every interface it listens on and every decoded event is logged with `--verbose`.
|
||||
|
||||
To collect packet-discovery data for decoding new features such as silver and item pickup tracking, pass a JSONL log path:
|
||||
|
||||
```shell
|
||||
aostats --verbose --log-path /tmp/aostats-discovery.jsonl
|
||||
```
|
||||
|
||||
This writes raw UDP payloads, decoded Photon messages, translated game messages, emitted app events, and possible item-id annotations to the JSONL file. If `--verbose` is also set, normal app logs are written to `/tmp/aostats-discovery.jsonl.app.log`.
|
||||
|
||||
On Linux, when the app has no permission to capture packets the backend still reports successful initialization; the app detects this and shows a "Fix capture permissions" button regardless.
|
||||
|
||||
## Is This Allowed
|
||||
<p align="center">
|
||||
<img src="assets/sbistatement.png">
|
||||
@@ -60,8 +122,9 @@ After first execution the app is going to create default configuration file name
|
||||
|
||||
## Prerequisites
|
||||
|
||||
- Python installed (python3.6+)
|
||||
- Python installed (python3.6+). On Linux the built-in decoder requires no extra runtime. On Windows/macOS use CPython 3.6-3.10 to get the `pyaoaddons` capture backend as a prebuilt wheel; newer versions require building it from source.
|
||||
- *Windows only prerequisites* https://github.com/libpnet/libpnet#windows
|
||||
- *macOS only prerequisites* libpcap (`brew install libpcap`)
|
||||
|
||||
|
||||
## All platforms
|
||||
@@ -79,10 +142,21 @@ After first execution the app is going to create default configuration file name
|
||||
```
|
||||
|
||||
|
||||
3. Install package
|
||||
3. Install the package with pip (this also installs the dependencies).
|
||||
On Linux this is all you need. On Windows/macOS, use Python 3.6-3.10 to get the `pyaoaddons` capture backend automatically.
|
||||
|
||||
```shell
|
||||
python setup.py install
|
||||
python -m pip install .
|
||||
```
|
||||
|
||||
On Windows/macOS with Python 3.11+ the capture backend is not installed
|
||||
automatically. Either use a Python 3.6-3.10 interpreter, or build
|
||||
`pyaoaddons` from source first:
|
||||
|
||||
```shell
|
||||
pip install setuptools-rust
|
||||
pip install --no-build-isolation git+https://github.com/mazurwiktor/aoaddons-python.git
|
||||
python -m pip install ".[capture]"
|
||||
```
|
||||
|
||||
4. Run the application
|
||||
|
||||
@@ -14,6 +14,9 @@ if not defined FOUND_PYTHON (goto python_not_found)
|
||||
%FOUND_PYTHON% -m venv python_env
|
||||
call .\python_env\Scripts\activate.bat
|
||||
|
||||
for /f "tokens=* delims=" %%a in ('python --version') do (echo Python version: %%a)
|
||||
for /f "tokens=* delims=" %%a in ('python -m pip --version') do (echo Pip version: %%a)
|
||||
|
||||
echo Installing newest version of aostats...
|
||||
python -m pip install --upgrade pip
|
||||
python -m pip install aostats
|
||||
|
||||
Regular → Executable
+44
-4
@@ -1,10 +1,50 @@
|
||||
#!/bin/bash
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Albion Online Stats launcher for Linux and macOS.
|
||||
|
||||
python -m venv python_env
|
||||
set -eu
|
||||
|
||||
source python_env/bin/activate
|
||||
FOUND_PYTHON=""
|
||||
|
||||
for app in python3 python; do
|
||||
if command -v "$app" >/dev/null 2>&1; then
|
||||
if "$app" -c 'import sys; sys.exit(0 if sys.version_info[0] == 3 else 1)' >/dev/null 2>&1; then
|
||||
FOUND_PYTHON="$app"
|
||||
break
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -z "$FOUND_PYTHON" ]; then
|
||||
echo "Error: python 3 was not found in the system." >&2
|
||||
echo "Install it with your package manager, e.g.:" >&2
|
||||
echo " Debian/Ubuntu: sudo apt install python3 python3-venv python3-pip" >&2
|
||||
echo " Fedora: sudo dnf install python3 python3-pip" >&2
|
||||
echo " Arch: sudo pacman -S python" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Found python: $FOUND_PYTHON ($("$FOUND_PYTHON" --version 2>&1))"
|
||||
|
||||
if ! "$FOUND_PYTHON" -m venv --help >/dev/null 2>&1; then
|
||||
echo "Error: the python 'venv' module is not available." >&2
|
||||
echo "On Debian/Ubuntu install it with: sudo apt install python3-venv" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# The pyaoaddons capture backend is only used on macOS now (Linux uses the
|
||||
# built-in AF_PACKET decoder and has no pyaoaddons wheel requirement).
|
||||
|
||||
echo "Creating python virtual environment..."
|
||||
"$FOUND_PYTHON" -m venv python_env
|
||||
|
||||
# shellcheck disable=SC1091
|
||||
. ./python_env/bin/activate
|
||||
|
||||
echo "Installing albion online stats..."
|
||||
python -m pip install --upgrade pip
|
||||
python -m pip install aostats
|
||||
python -m pip install --upgrade aostats
|
||||
|
||||
aostats
|
||||
echo "Starting Albion Online Stats..."
|
||||
aostats "$@"
|
||||
|
||||
@@ -3,13 +3,24 @@ from setuptools import setup, find_packages
|
||||
from src.version import version
|
||||
|
||||
install_requires = [
|
||||
"requests==2.26.0",
|
||||
"pyside2==5.15.2",
|
||||
"toml==0.10.2",
|
||||
"pillow==8.3.1",
|
||||
"pyaoaddons==0.2.7.dev"
|
||||
"requests>=2.26",
|
||||
"PySide6>=6.2",
|
||||
"toml>=0.10.2",
|
||||
"pillow>=8.4",
|
||||
# On Linux the app ships a pure-Python Protocol18 decoder and captures with
|
||||
# AF_PACKET directly, so no native backend is needed. On Windows/macOS the
|
||||
# pyaoaddons packet capture backend is still used; only 0.2.8 is released
|
||||
# and it ships prebuilt wheels for CPython 3.6-3.10 only. On newer Python
|
||||
# versions it must be built from source (see the 'capture' extra).
|
||||
"pyaoaddons==0.2.8; python_version < '3.11' and sys_platform != 'linux'",
|
||||
]
|
||||
|
||||
extras_require = {
|
||||
# Force installation of the packet capture backend, e.g. when building
|
||||
# pyaoaddons from source or using an unsupported Python version.
|
||||
'capture': ['pyaoaddons==0.2.8'],
|
||||
}
|
||||
|
||||
this_directory = path.abspath(path.dirname(__file__))
|
||||
with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f:
|
||||
long_description = f.read()
|
||||
@@ -25,6 +36,7 @@ with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f:
|
||||
packages=find_packages('.', include=('src*')),
|
||||
include_package_data=True,
|
||||
install_requires=install_requires,
|
||||
extras_require=extras_require,
|
||||
entry_points={
|
||||
'console_scripts': [
|
||||
'aostats = src.__main__:run'
|
||||
|
||||
+65
-13
@@ -1,6 +1,27 @@
|
||||
import logging
|
||||
|
||||
from .environment import TEST_ENV_ENABLED
|
||||
from . import environment
|
||||
from .utils import platform_utils
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class InitializationResult:
|
||||
Ok = 0
|
||||
UnknownFailure = 1
|
||||
NetworkInterfaceListMissing = 2
|
||||
BackendNotInstalled = 3
|
||||
|
||||
|
||||
try:
|
||||
import pyaoaddons # type: ignore
|
||||
except:
|
||||
|
||||
BACKEND_AVAILABLE = True
|
||||
except ImportError:
|
||||
BACKEND_AVAILABLE = False
|
||||
|
||||
class pyaoaddons: # type: ignore
|
||||
@staticmethod
|
||||
def initialize():
|
||||
@@ -10,15 +31,6 @@ except:
|
||||
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,
|
||||
@@ -26,24 +38,64 @@ INITIALIZATION_RESULT = {
|
||||
2: InitializationResult.NetworkInterfaceListMissing
|
||||
}
|
||||
|
||||
# On Linux we ship a pure-Python Protocol18 decoder and use AF_PACKET directly,
|
||||
# so pyaoaddons is not required.
|
||||
NATIVE_BACKEND_AVAILABLE = platform_utils.is_linux()
|
||||
|
||||
_capture = None
|
||||
|
||||
|
||||
def initialize():
|
||||
if TEST_ENV_ENABLED:
|
||||
return InitializationResult.Ok
|
||||
|
||||
if NATIVE_BACKEND_AVAILABLE:
|
||||
return InitializationResult.Ok
|
||||
|
||||
if not BACKEND_AVAILABLE:
|
||||
return InitializationResult.BackendNotInstalled
|
||||
|
||||
try:
|
||||
result = pyaoaddons.initialize()
|
||||
|
||||
return INITIALIZATION_RESULT[result]
|
||||
except:
|
||||
pass
|
||||
except Exception:
|
||||
return InitializationResult.UnknownFailure
|
||||
|
||||
|
||||
def subscribe(callback):
|
||||
if TEST_ENV_ENABLED:
|
||||
return _testing_call_sequence(callback)
|
||||
_testing_call_sequence(callback)
|
||||
return True
|
||||
|
||||
if NATIVE_BACKEND_AVAILABLE:
|
||||
return _start_native_backend(callback)
|
||||
|
||||
if BACKEND_AVAILABLE:
|
||||
pyaoaddons.subscribe(callback)
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def _start_native_backend(callback):
|
||||
global _capture
|
||||
|
||||
if _capture is not None:
|
||||
return True
|
||||
|
||||
from .decode.pipeline import Pipeline
|
||||
from .net.capture import CaptureEngine
|
||||
|
||||
pipeline = Pipeline(callback)
|
||||
capture = CaptureEngine(pipeline.on_udp)
|
||||
if not capture.start():
|
||||
logger.error(
|
||||
"native capture backend could not start; "
|
||||
"check packet capture permissions")
|
||||
return False
|
||||
_capture = capture
|
||||
return True
|
||||
|
||||
|
||||
def _testing_call_sequence(callback):
|
||||
|
||||
@@ -8,6 +8,8 @@ EvNameLeaveCombat: str = 'LeaveCombat'
|
||||
EvNameUpdateFame: str = 'UpdateFame'
|
||||
EvNameUpdateItems: str = 'UpdateItems'
|
||||
EvNameUpdateParty: str = 'UpdateParty'
|
||||
EvNameSilverGained: str = 'SilverGained'
|
||||
EvNameItemCollected: str = 'ItemCollected'
|
||||
|
||||
EvKeyName: str = 'name'
|
||||
EvKeyValue: str = 'value'
|
||||
@@ -15,3 +17,7 @@ EvKeySource: str = 'source'
|
||||
EvKeyTarget: str = 'target'
|
||||
EvKeyId: str = 'id'
|
||||
EvKeyPlayerNames: str = 'player_names'
|
||||
EvKeyItemId: str = 'item_id'
|
||||
EvKeyItemName: str = 'item_name'
|
||||
EvKeyQuantity: str = 'quantity'
|
||||
EvKeySilverType: str = 'silver_type'
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
from .photon import PhotonDecoder, PhotonMessage
|
||||
from .world import World
|
||||
@@ -0,0 +1,110 @@
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from typing import Any, Dict, List
|
||||
|
||||
from ..environment import discovery_log_path
|
||||
from . import items as itemdb
|
||||
|
||||
|
||||
_lock = threading.Lock()
|
||||
_initialized = False
|
||||
|
||||
|
||||
def enabled() -> bool:
|
||||
return bool(discovery_log_path())
|
||||
|
||||
|
||||
def log(record_type: str, **fields):
|
||||
path = discovery_log_path()
|
||||
if not path:
|
||||
return
|
||||
|
||||
global _initialized
|
||||
with _lock:
|
||||
log_dir = os.path.dirname(path)
|
||||
if log_dir:
|
||||
os.makedirs(log_dir, exist_ok=True)
|
||||
mode = 'a' if _initialized else 'w'
|
||||
with open(path, mode, encoding='utf-8') as out:
|
||||
if not _initialized:
|
||||
out.write(json.dumps({
|
||||
'type': 'session_start',
|
||||
'timestamp': _timestamp(),
|
||||
'format': 'aostats-discovery-jsonl-v1',
|
||||
}, sort_keys=True) + '\n')
|
||||
_initialized = True
|
||||
out.write(json.dumps({
|
||||
'type': record_type,
|
||||
'timestamp': _timestamp(),
|
||||
**_clean(fields),
|
||||
}, sort_keys=True) + '\n')
|
||||
|
||||
|
||||
def message_record(message) -> Dict[str, Any]:
|
||||
params = getattr(message, 'params', {}) or {}
|
||||
return {
|
||||
'kind': getattr(message, 'kind', None),
|
||||
'code': getattr(message, 'code', None),
|
||||
'return_code': getattr(message, 'return_code', None),
|
||||
'debug_message': _clean(getattr(message, 'debug_message', None)),
|
||||
'params': _clean(params),
|
||||
'item_id_candidates': item_candidates(params),
|
||||
}
|
||||
|
||||
|
||||
def game_message_record(game_message) -> Dict[str, Any]:
|
||||
params = getattr(game_message, 'params', {}) or {}
|
||||
return {
|
||||
'name': getattr(game_message, 'name', None),
|
||||
'code': getattr(game_message, 'code', None),
|
||||
'params': _clean(params),
|
||||
'item_id_candidates': item_candidates(params),
|
||||
}
|
||||
|
||||
|
||||
def item_candidates(params: Dict[Any, Any]) -> List[Dict[str, Any]]:
|
||||
db = itemdb.get_db()
|
||||
found: List[Dict[str, Any]] = []
|
||||
for key, value in (params or {}).items():
|
||||
for path, number in _walk_numbers(value, str(key)):
|
||||
if number in db:
|
||||
found.append({
|
||||
'path': path,
|
||||
'id': number,
|
||||
'unique_name': db[number],
|
||||
})
|
||||
return found
|
||||
|
||||
|
||||
def _timestamp() -> str:
|
||||
return datetime.now(timezone.utc).isoformat(timespec='milliseconds')
|
||||
|
||||
|
||||
def _clean(value):
|
||||
if isinstance(value, bytes):
|
||||
return {'bytes_hex': value.hex(), 'len': len(value)}
|
||||
if isinstance(value, dict):
|
||||
return {str(k): _clean(v) for k, v in value.items()}
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [_clean(v) for v in value]
|
||||
return value
|
||||
|
||||
|
||||
def _walk_numbers(value, path: str):
|
||||
if isinstance(value, bool):
|
||||
return
|
||||
if isinstance(value, int):
|
||||
yield path, value
|
||||
return
|
||||
if isinstance(value, float) and value.is_integer():
|
||||
yield path, int(value)
|
||||
return
|
||||
if isinstance(value, dict):
|
||||
for key, item in value.items():
|
||||
yield from _walk_numbers(item, f'{path}.{key}')
|
||||
return
|
||||
if isinstance(value, (list, tuple)):
|
||||
for i, item in enumerate(value):
|
||||
yield from _walk_numbers(item, f'{path}[{i}]')
|
||||
@@ -0,0 +1,66 @@
|
||||
import os
|
||||
from typing import Dict, Optional
|
||||
|
||||
_ITEM_DB: Optional[Dict[int, str]] = None
|
||||
_ITEM_NAME_DB: Optional[Dict[int, str]] = None
|
||||
_ITEM_DB_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'static', 'item_ids.txt')
|
||||
_ITEM_NAMES_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'static', 'item_names.txt')
|
||||
|
||||
|
||||
def _load_file(path: str) -> Dict[int, str]:
|
||||
db = {}
|
||||
with open(path, encoding='utf-8') as f:
|
||||
for line in f:
|
||||
parts = line.strip().split(',', 1)
|
||||
if len(parts) != 2:
|
||||
continue
|
||||
try:
|
||||
_id = int(parts[0])
|
||||
except ValueError:
|
||||
continue
|
||||
name = parts[1].strip()
|
||||
if name:
|
||||
db[_id] = name
|
||||
return db
|
||||
|
||||
|
||||
def get_db() -> Dict[int, str]:
|
||||
global _ITEM_DB
|
||||
if _ITEM_DB is None:
|
||||
_ITEM_DB = _load_file(_ITEM_DB_PATH)
|
||||
return _ITEM_DB
|
||||
|
||||
|
||||
def get_name_db() -> Dict[int, str]:
|
||||
global _ITEM_NAME_DB
|
||||
if _ITEM_NAME_DB is None:
|
||||
if os.path.exists(_ITEM_NAMES_PATH):
|
||||
_ITEM_NAME_DB = _load_file(_ITEM_NAMES_PATH)
|
||||
else:
|
||||
_ITEM_NAME_DB = {}
|
||||
return _ITEM_NAME_DB
|
||||
|
||||
|
||||
def display_name(item_id: int) -> str:
|
||||
return get_name_db().get(item_id) or get_db().get(item_id) or str(item_id)
|
||||
|
||||
|
||||
ITEMS_SLOTS = ('weapon', 'offhand', 'helmet', 'armor', 'boots', 'bag', 'cape', 'mount', 'potion', 'food')
|
||||
|
||||
|
||||
def decode_items(item_array) -> Dict[str, Optional[str]]:
|
||||
"""Maps an equipment number array to slot -> item unique name.
|
||||
|
||||
Always returns all slots (aoaddons' ``Items`` struct keeps every field,
|
||||
using ``None`` for empty/missing equipment) so downstream consumers can
|
||||
index ``items['weapon']`` unconditionally.
|
||||
"""
|
||||
db = get_db()
|
||||
items: Dict[str, Optional[str]] = {slot: None for slot in ITEMS_SLOTS}
|
||||
for slot, _id in enumerate(ITEMS_SLOTS):
|
||||
if item_array is None or slot >= len(item_array):
|
||||
break
|
||||
code = item_array[slot]
|
||||
if code and code in db:
|
||||
items[_id] = db[code]
|
||||
return items
|
||||
@@ -0,0 +1,68 @@
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from typing import List
|
||||
|
||||
from ..utils import platform_utils
|
||||
|
||||
FILE_NAME = 'last-party.json'
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def memory_path() -> str:
|
||||
cfg_dir = platform_utils.config_dir()
|
||||
if not cfg_dir:
|
||||
cfg_dir = os.getcwd()
|
||||
return os.path.join(cfg_dir, FILE_NAME)
|
||||
|
||||
|
||||
def load_last_party() -> List[str]:
|
||||
try:
|
||||
with open(memory_path(), 'r') as party_file:
|
||||
data = json.load(party_file)
|
||||
except (OSError, json.JSONDecodeError):
|
||||
logger.debug("no readable remembered party at %s", memory_path())
|
||||
return []
|
||||
names = data.get('player_names') if isinstance(data, dict) else None
|
||||
if not isinstance(names, list):
|
||||
logger.debug("remembered party file has no player_names: %s", memory_path())
|
||||
return []
|
||||
clean_names = _clean_names(names)
|
||||
logger.debug("loaded remembered party from %s: %s", memory_path(), clean_names)
|
||||
return clean_names
|
||||
|
||||
|
||||
def save_last_party(names: List[str]):
|
||||
clean_names = _clean_names(names)
|
||||
if not clean_names:
|
||||
clear_last_party()
|
||||
return
|
||||
path = memory_path()
|
||||
directory = os.path.dirname(path)
|
||||
if directory:
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
with open(path, 'w') as party_file:
|
||||
json.dump({'player_names': clean_names}, party_file)
|
||||
logger.debug("saved remembered party to %s: %s", path, clean_names)
|
||||
|
||||
|
||||
def clear_last_party():
|
||||
try:
|
||||
os.remove(memory_path())
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
logger.debug("cleared remembered party at %s", memory_path())
|
||||
|
||||
|
||||
def _clean_names(names: List[str]) -> List[str]:
|
||||
out = []
|
||||
seen = set()
|
||||
for name in names:
|
||||
if not isinstance(name, str) or not name or name in seen:
|
||||
continue
|
||||
seen.add(name)
|
||||
out.append(name)
|
||||
return out
|
||||
@@ -0,0 +1,380 @@
|
||||
import struct
|
||||
import logging
|
||||
from collections import namedtuple
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
PROTOCOL18_SIGNAL = 0xF3
|
||||
|
||||
# Photon command types inside an eNet envelope
|
||||
CMD_SEND_RELIABLE = 0x06
|
||||
CMD_SEND_UNRELIABLE = 0x07
|
||||
CMD_SEND_FRAGMENT = 0x08
|
||||
CMD_SEND_UNRELIABLE_FRAGMENT = 0x0B
|
||||
CMD_ACKNOWLEDGE = 0x03
|
||||
CMD_PING = 0x05
|
||||
CMD_LOGOUT = 0x04
|
||||
|
||||
# Photon message types
|
||||
MSG_OPERATION_REQUEST = 0x02
|
||||
MSG_OPERATION_RESPONSE = 0x03
|
||||
MSG_EVENT_DATA = 0x04
|
||||
MSG_INTERNAL_REQUEST = 0x06
|
||||
MSG_INTERNAL_RESPONSE = 0x07
|
||||
|
||||
P18 = {
|
||||
'Boolean': 2, 'Byte': 3, 'Short': 4, 'Float': 5, 'Double': 6, 'String': 7,
|
||||
'Null': 8, 'CompressedInt': 9, 'CompressedLong': 10, 'Int1': 11, 'Int1Neg': 12,
|
||||
'Int2': 13, 'Int2Neg': 14, 'Long1': 15, 'Long1Neg': 16, 'Long2': 17, 'Long2Neg': 18,
|
||||
'Custom': 19, 'Dictionary': 20, 'Hashtable': 21, 'ObjectArray': 23,
|
||||
'OperationRequest': 24, 'OperationResponse': 25, 'EventData': 26,
|
||||
'BooleanFalse': 27, 'BooleanTrue': 28, 'ShortZero': 29, 'IntZero': 30,
|
||||
'LongZero': 31, 'FloatZero': 32, 'DoubleZero': 33, 'ByteZero': 34,
|
||||
'Array': 64, 'BooleanArray': 66, 'ByteArray': 67, 'ShortArray': 68,
|
||||
'FloatArray': 69, 'DoubleArray': 70, 'StringArray': 71, 'CompressedIntArray': 73,
|
||||
'CompressedLongArray': 74, 'CustomTypeArray': 83, 'DictionaryArray': 84,
|
||||
'HashtableArray': 85, 'CustomTypeSlim': 128,
|
||||
}
|
||||
|
||||
PhotonMessage = namedtuple(
|
||||
'PhotonMessage', ('kind', 'code', 'params', 'return_code', 'debug_message'))
|
||||
|
||||
GAME_PORT = 5056
|
||||
|
||||
FRAG_HEADER_LEN = 20 # 5 x u32
|
||||
|
||||
|
||||
class DecodeError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def _need(buf: bytes, pos: int, n: int, what: str):
|
||||
if pos + n > len(buf):
|
||||
raise DecodeError(f"not enough bytes for {what} at {pos}")
|
||||
|
||||
|
||||
def rd_u8(buf: bytes, pos: int):
|
||||
_need(buf, pos, 1, "u8")
|
||||
return buf[pos], pos + 1
|
||||
|
||||
|
||||
def rd_i16le(buf: bytes, pos: int):
|
||||
_need(buf, pos, 2, "i16le")
|
||||
return struct.unpack("<h", buf[pos:pos + 2])[0], pos + 2
|
||||
|
||||
|
||||
def rd_u16le(buf: bytes, pos: int):
|
||||
_need(buf, pos, 2, "u16le")
|
||||
return struct.unpack("<H", buf[pos:pos + 2])[0], pos + 2
|
||||
|
||||
|
||||
def rd_u16be(buf: bytes, pos: int):
|
||||
_need(buf, pos, 2, "u16be")
|
||||
return struct.unpack(">H", buf[pos:pos + 2])[0], pos + 2
|
||||
|
||||
|
||||
def rd_u32be(buf: bytes, pos: int):
|
||||
_need(buf, pos, 4, "u32be")
|
||||
return struct.unpack(">I", buf[pos:pos + 4])[0], pos + 4
|
||||
|
||||
|
||||
def rd_u32le(buf: bytes, pos: int):
|
||||
_need(buf, pos, 4, "u32le")
|
||||
return struct.unpack("<I", buf[pos:pos + 4])[0], pos + 4
|
||||
|
||||
|
||||
def rd_f32le(buf: bytes, pos: int):
|
||||
_need(buf, pos, 4, "f32le")
|
||||
return struct.unpack("<f", buf[pos:pos + 4])[0], pos + 4
|
||||
|
||||
|
||||
def rd_f64le(buf: bytes, pos: int):
|
||||
_need(buf, pos, 8, "f64le")
|
||||
return struct.unpack("<d", buf[pos:pos + 8])[0], pos + 8
|
||||
|
||||
|
||||
def rd_varint(buf: bytes, pos: int):
|
||||
value = 0
|
||||
for shift in range(0, 64, 7):
|
||||
b, pos = rd_u8(buf, pos)
|
||||
if b & 0x80 == 0:
|
||||
return value | (b << shift), pos
|
||||
value |= (b & 0x7F) << shift
|
||||
raise DecodeError("varint overflow")
|
||||
|
||||
|
||||
def zigzag(v):
|
||||
return (v >> 1) ^ (-(v & 1))
|
||||
|
||||
|
||||
def read_string18(buf: bytes, pos: int):
|
||||
slen, pos = rd_varint(buf, pos)
|
||||
if slen == 0:
|
||||
return "", pos
|
||||
_need(buf, pos, slen, "string")
|
||||
return buf[pos:pos + slen].decode('utf-8', 'replace'), pos + slen
|
||||
|
||||
|
||||
def deserialize18(buf: bytes, pos: int, tc: int):
|
||||
if tc >= P18['CustomTypeSlim']:
|
||||
return ('custom', tc - P18['CustomTypeSlim']), pos
|
||||
if tc == P18['Boolean']:
|
||||
v, p = rd_u8(buf, pos)
|
||||
return bool(v), p
|
||||
if tc in (P18['Byte'], P18['ByteZero']):
|
||||
if tc == P18['ByteZero']:
|
||||
return 0, pos
|
||||
return rd_u8(buf, pos)
|
||||
if tc == P18['Short']:
|
||||
return rd_i16le(buf, pos)
|
||||
if tc == P18['Float']:
|
||||
return rd_f32le(buf, pos)
|
||||
if tc == P18['Double']:
|
||||
return rd_f64le(buf, pos)
|
||||
if tc == P18['String']:
|
||||
return read_string18(buf, pos)
|
||||
if tc in (P18['Null'], P18['BooleanFalse'], P18['BooleanTrue'],
|
||||
P18['ShortZero'], P18['IntZero'], P18['LongZero'],
|
||||
P18['FloatZero'], P18['DoubleZero']):
|
||||
return None, pos
|
||||
if tc == P18['CompressedInt']:
|
||||
v, p = rd_varint(buf, pos)
|
||||
return zigzag(v), p
|
||||
if tc == P18['CompressedLong']:
|
||||
v, p = rd_varint(buf, pos)
|
||||
return zigzag(v), p
|
||||
if tc in (P18['Int1'], P18['Long1']):
|
||||
return rd_u8(buf, pos)
|
||||
if tc == P18['Int1Neg'] or tc == P18['Long1Neg']:
|
||||
v, p = rd_u8(buf, pos)
|
||||
return -v, p
|
||||
if tc in (P18['Int2'], P18['Long2']):
|
||||
return rd_u16le(buf, pos)
|
||||
if tc == P18['Int2Neg'] or tc == P18['Long2Neg']:
|
||||
v, p = rd_u16le(buf, pos)
|
||||
return -v, p
|
||||
if tc == P18['ByteArray']:
|
||||
n, p = rd_varint(buf, pos)
|
||||
_need(buf, p, n, "byte array")
|
||||
return bytes(buf[p:p + n]), p + n
|
||||
if tc == P18['ShortArray']:
|
||||
return _read_number_array(buf, pos, lambda b, p: rd_i16le(b, p), "short array")
|
||||
if tc == P18['FloatArray']:
|
||||
return _read_number_array(buf, pos, rd_f32le, "float array")
|
||||
if tc == P18['DoubleArray']:
|
||||
return _read_number_array(buf, pos, rd_f64le, "double array")
|
||||
if tc == P18['StringArray']:
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
s, p = read_string18(buf, p)
|
||||
out.append(s)
|
||||
return out, p
|
||||
if tc == P18['CompressedIntArray']:
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
v, p = rd_varint(buf, p)
|
||||
out.append(zigzag(v))
|
||||
return out, p
|
||||
if tc == P18['CompressedLongArray']:
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
v, p = rd_varint(buf, p)
|
||||
out.append(zigzag(v))
|
||||
return out, p
|
||||
if tc == P18['BooleanArray']:
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
v, p = rd_u8(buf, p)
|
||||
out.append(bool(v))
|
||||
return out, p
|
||||
if tc in (P18['Array'], P18['ObjectArray'], P18['CustomTypeArray']):
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
et, p = rd_u8(buf, p)
|
||||
v, p = deserialize18(buf, p, et)
|
||||
out.append(v)
|
||||
return out, p
|
||||
if tc in (P18['Dictionary'], P18['Hashtable'], P18['DictionaryArray'], P18['HashtableArray']):
|
||||
return _decode_map18(buf, pos, tc)
|
||||
if tc == P18['Custom']:
|
||||
t, p = rd_u8(buf, pos)
|
||||
n, p = rd_varint(buf, p)
|
||||
_need(buf, p, n, "custom")
|
||||
return ('custom', t, bytes(buf[p:p + n])), p + n
|
||||
raise DecodeError(f"unhandled P18 type 0x{tc:02X} at {pos}")
|
||||
|
||||
|
||||
def _read_number_array(buf: bytes, pos: int, reader, what: str):
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = []
|
||||
for _ in range(n):
|
||||
v, p = reader(buf, p)
|
||||
out.append(v)
|
||||
return out, p
|
||||
|
||||
|
||||
def _decode_map18(buf: bytes, pos: int, tc: int):
|
||||
if tc in (P18['Dictionary'], P18['DictionaryArray']):
|
||||
kt, pos0 = rd_u8(buf, pos)
|
||||
vt, p = rd_u8(buf, pos0)
|
||||
n, p = rd_varint(buf, p)
|
||||
out = {}
|
||||
for _ in range(n):
|
||||
if kt == 0:
|
||||
kt2, p = rd_u8(buf, p)
|
||||
k, p = deserialize18(buf, p, kt2)
|
||||
else:
|
||||
k, p = deserialize18(buf, p, kt)
|
||||
if vt == 0:
|
||||
vt2, p = rd_u8(buf, p)
|
||||
v, p = deserialize18(buf, p, vt2)
|
||||
else:
|
||||
v, p = deserialize18(buf, p, vt)
|
||||
out[k] = v
|
||||
return out, p
|
||||
n, p = rd_varint(buf, pos)
|
||||
out = {}
|
||||
for _ in range(n):
|
||||
kt, p = rd_u8(buf, p)
|
||||
k, p = deserialize18(buf, p, kt)
|
||||
vt, p = rd_u8(buf, p)
|
||||
v, p = deserialize18(buf, p, vt)
|
||||
out[k] = v
|
||||
return out, p
|
||||
|
||||
|
||||
def decode_params18(buf: bytes, pos: int):
|
||||
size, pos = rd_u8(buf, pos)
|
||||
out = {}
|
||||
for _ in range(size):
|
||||
key, pos = rd_u8(buf, pos)
|
||||
tc, pos = rd_u8(buf, pos)
|
||||
val, pos = deserialize18(buf, pos, tc)
|
||||
out[key] = val
|
||||
return out, pos
|
||||
|
||||
|
||||
def decode_message18(buf: bytes, pos: int):
|
||||
_, pos = rd_u8(buf, pos) # signal byte 0xF3
|
||||
msg_type, pos = rd_u8(buf, pos)
|
||||
msg_type &= 0x7F
|
||||
if msg_type in (MSG_OPERATION_REQUEST, MSG_INTERNAL_REQUEST):
|
||||
code, pos = rd_u8(buf, pos)
|
||||
params, pos = decode_params18(buf, pos)
|
||||
return PhotonMessage('Request', code, params, None, None), pos
|
||||
if msg_type in (MSG_OPERATION_RESPONSE, MSG_INTERNAL_RESPONSE):
|
||||
code, pos = rd_u8(buf, pos)
|
||||
ret, pos = rd_i16le(buf, pos)
|
||||
dv_type, pos = rd_u8(buf, pos)
|
||||
dv, pos = deserialize18(buf, pos, dv_type)
|
||||
params, pos = decode_params18(buf, pos)
|
||||
return PhotonMessage('Response', code, params, ret, dv), pos
|
||||
if msg_type == MSG_EVENT_DATA:
|
||||
code, pos = rd_u8(buf, pos)
|
||||
params, pos = decode_params18(buf, pos)
|
||||
return PhotonMessage('Event', code, params, None, None), pos
|
||||
raise DecodeError(f"unknown message type 0x{msg_type:02X}")
|
||||
|
||||
|
||||
class FragmentAssembler:
|
||||
"""Reassembles eNet SendFragment sequences into whole Photon messages."""
|
||||
|
||||
def __init__(self):
|
||||
self._fragments: Dict[tuple, dict] = {}
|
||||
|
||||
def add(self, peer: int, start_seq: int, fragment_count: int,
|
||||
fragment_number: int, total_length: int, data: bytes):
|
||||
key = (peer, start_seq)
|
||||
group = self._fragments.setdefault(
|
||||
key, {'count': fragment_count, 'parts': {}, 'total': total_length})
|
||||
if group['count'] != fragment_count:
|
||||
self._fragments.pop(key, None)
|
||||
return None
|
||||
group['parts'][fragment_number] = data
|
||||
if len(group['parts']) < group['count']:
|
||||
return None
|
||||
payload = b''.join(group['parts'][i] for i in range(group['count']))
|
||||
self._fragments.pop(key, None)
|
||||
return payload
|
||||
|
||||
|
||||
class PhotonDecoder:
|
||||
def __init__(self):
|
||||
self.assembler = FragmentAssembler()
|
||||
|
||||
def decode_packet(self, payload: bytes, peer: int = 0) -> List[PhotonMessage]:
|
||||
messages: List[PhotonMessage] = []
|
||||
try:
|
||||
return self._decode_packet(payload, peer, messages)
|
||||
except DecodeError as e:
|
||||
logger.debug("dropping undecodable UDP payload: %s", e)
|
||||
return messages
|
||||
|
||||
def _decode_packet(self, payload: bytes, peer: int,
|
||||
messages: List[PhotonMessage]) -> List[PhotonMessage]:
|
||||
pos = 0
|
||||
_peer, pos = rd_u16be(payload, pos)
|
||||
crc, pos = rd_u8(payload, pos)
|
||||
count, pos = rd_u8(payload, pos)
|
||||
_ts, pos = rd_u32be(payload, pos)
|
||||
_ch, pos = rd_u32be(payload, pos)
|
||||
for _ in range(count):
|
||||
cmd_type, pos = rd_u8(payload, pos)
|
||||
_channel, pos = rd_u8(payload, pos)
|
||||
_flags, pos = rd_u8(payload, pos)
|
||||
_reserved, pos = rd_u8(payload, pos)
|
||||
length, pos = rd_u32be(payload, pos)
|
||||
_seq, pos = rd_u32be(payload, pos)
|
||||
data_len = length - 12
|
||||
if cmd_type == CMD_SEND_FRAGMENT:
|
||||
start_seq, pos = rd_u32be(payload, pos)
|
||||
fragment_count, pos = rd_u32be(payload, pos)
|
||||
fragment_number, pos = rd_u32be(payload, pos)
|
||||
total_length, pos = rd_u32be(payload, pos)
|
||||
_offset, pos = rd_u32be(payload, pos)
|
||||
data = payload[pos:pos + data_len - FRAG_HEADER_LEN]
|
||||
pos += data_len - FRAG_HEADER_LEN
|
||||
reassembled = self.assembler.add(
|
||||
peer, start_seq, fragment_count, fragment_number, total_length, data)
|
||||
if reassembled is not None:
|
||||
messages.extend(self._decode_message(reassembled, peer))
|
||||
continue
|
||||
if cmd_type in (CMD_ACKNOWLEDGE, CMD_PING):
|
||||
pos += data_len
|
||||
continue
|
||||
if cmd_type == CMD_LOGOUT:
|
||||
continue
|
||||
if cmd_type in (CMD_SEND_RELIABLE, CMD_SEND_UNRELIABLE,
|
||||
CMD_SEND_UNRELIABLE_FRAGMENT):
|
||||
if cmd_type in (CMD_SEND_UNRELIABLE,
|
||||
CMD_SEND_UNRELIABLE_FRAGMENT):
|
||||
pos += 4 # unknown/unreliable sequence trailers
|
||||
data_len -= 4
|
||||
msg_bytes = payload[pos:pos + data_len]
|
||||
pos += data_len
|
||||
messages.extend(self._decode_message(msg_bytes, peer))
|
||||
continue
|
||||
pos += data_len
|
||||
return messages
|
||||
|
||||
def _decode_message(self, msg_bytes: bytes, peer: int) -> List[PhotonMessage]:
|
||||
if not msg_bytes:
|
||||
return []
|
||||
signal = msg_bytes[0]
|
||||
if signal != PROTOCOL18_SIGNAL:
|
||||
logger.debug("dropping message with unknown signal 0x%02X", signal)
|
||||
return []
|
||||
try:
|
||||
msg, _ = decode_message18(msg_bytes, 0)
|
||||
except DecodeError as e:
|
||||
logger.debug("dropping undecodable Photon message: %s", e)
|
||||
return []
|
||||
logger.debug("decoded Photon message: %s", msg)
|
||||
return [msg]
|
||||
@@ -0,0 +1,52 @@
|
||||
import threading
|
||||
import logging
|
||||
from typing import Callable, List
|
||||
|
||||
from .photon import PhotonDecoder, PhotonMessage
|
||||
from .translate import into_game_message
|
||||
from .world import World
|
||||
from . import discovery
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Pipeline:
|
||||
"""Decodes captured UDP payloads into app events (aoaddons lib.rs flow)."""
|
||||
|
||||
def __init__(self, emit: Callable[[dict], None]):
|
||||
self.emit = emit
|
||||
self.decoder = PhotonDecoder()
|
||||
self.world = World()
|
||||
self._lock = threading.RLock()
|
||||
|
||||
def on_udp(self, payload: bytes):
|
||||
logger.debug("received UDP payload: %d bytes", len(payload))
|
||||
discovery.log(
|
||||
'udp_payload',
|
||||
length=len(payload),
|
||||
payload_hex=payload.hex())
|
||||
messages = self.decoder.decode_packet(payload)
|
||||
if not messages:
|
||||
return
|
||||
with self._lock:
|
||||
for message in messages:
|
||||
discovery.log(
|
||||
'photon_message',
|
||||
message=discovery.message_record(message))
|
||||
for event in self._events_from_message(message):
|
||||
self.emit(event)
|
||||
|
||||
def _events_from_message(self, message: PhotonMessage) -> List[dict]:
|
||||
game_message = into_game_message(message)
|
||||
if game_message is None:
|
||||
return []
|
||||
discovery.log(
|
||||
'game_message',
|
||||
message=discovery.game_message_record(game_message))
|
||||
logger.debug("translated game message: %s", game_message)
|
||||
events = self.world.transform(game_message)
|
||||
for event in events:
|
||||
discovery.log('app_event', event=event)
|
||||
logger.debug("emitting app event: %s", event)
|
||||
return events
|
||||
@@ -0,0 +1,249 @@
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Optional, List
|
||||
|
||||
from .photon import PhotonMessage
|
||||
|
||||
# Photon message code used for game traffic (aoaddons pipeline guard)
|
||||
PHOTON_GAME_CODE = 1
|
||||
|
||||
# Current opcodes (albion-lens numbering, verified against captured traffic)
|
||||
EVENT_LEAVE = 1
|
||||
EVENT_HEALTH_UPDATE = 6
|
||||
EVENT_NEW_CHARACTER = 29
|
||||
EVENT_ITEM_GAINED = 32
|
||||
EVENT_UPDATE_FAME = 82
|
||||
EVENT_CHARACTER_EQUIPMENT_CHANGED = 90
|
||||
EVENT_REGENERATION_HEALTH_CHANGED = 91
|
||||
EVENT_SILVER_GAINED = 153
|
||||
EVENT_KNOCKED_DOWN = 166
|
||||
EVENT_PARTY_INVITATION = 229
|
||||
EVENT_PARTY_JOIN_REQUEST = 230
|
||||
EVENT_PARTY_JOINED = 231
|
||||
EVENT_PARTY_DISBANDED = 232
|
||||
EVENT_PARTY_PLAYER_JOINED = 233
|
||||
EVENT_PARTY_CHANGED_ORDER = 234
|
||||
EVENT_PARTY_PLAYER_LEFT = 235
|
||||
|
||||
# Operation codes (response parameter 253)
|
||||
OPERATION_JOIN = 2
|
||||
OPERATION_CHANGE_CLUSTER = 41
|
||||
|
||||
|
||||
def _int(value) -> Optional[int]:
|
||||
if isinstance(value, bool):
|
||||
return int(value)
|
||||
if isinstance(value, (int, float)):
|
||||
return int(value)
|
||||
return None
|
||||
|
||||
|
||||
def _float(value) -> Optional[float]:
|
||||
if isinstance(value, bool):
|
||||
return float(value)
|
||||
if isinstance(value, (int, float)):
|
||||
return float(value)
|
||||
return None
|
||||
|
||||
|
||||
def _string(value) -> Optional[str]:
|
||||
if isinstance(value, str):
|
||||
return value
|
||||
return None
|
||||
|
||||
|
||||
def _string_list(value) -> List[str]:
|
||||
if not isinstance(value, list):
|
||||
return []
|
||||
out = []
|
||||
for item in value:
|
||||
s = _string(item)
|
||||
if s:
|
||||
out.append(s)
|
||||
return out
|
||||
|
||||
|
||||
def _as_int_list(value) -> List[int]:
|
||||
if isinstance(value, bytes):
|
||||
return list(value)
|
||||
if isinstance(value, list):
|
||||
out = []
|
||||
for v in value:
|
||||
i = _int(v)
|
||||
if i is not None:
|
||||
out.append(i)
|
||||
return out
|
||||
return []
|
||||
|
||||
|
||||
@dataclass
|
||||
class GameMessage:
|
||||
name: str
|
||||
code: int
|
||||
params: dict = field(default_factory=dict)
|
||||
|
||||
def param(self, key: int):
|
||||
return self.params.get(key)
|
||||
|
||||
|
||||
def into_game_message(message: PhotonMessage) -> Optional[GameMessage]:
|
||||
if message.code != PHOTON_GAME_CODE:
|
||||
return None
|
||||
if message.kind == 'Event':
|
||||
code = _int(message.params.get(252))
|
||||
if code is None:
|
||||
names = msg_party_roster_names_from_params(message.params)
|
||||
if names:
|
||||
return GameMessage('PartyRoster', 0, message.params)
|
||||
return None
|
||||
name = EVENT_NAMES.get(code)
|
||||
if name is None:
|
||||
return None
|
||||
return GameMessage(name, code, message.params)
|
||||
if message.kind in ('Request', 'Response'):
|
||||
code = _int(message.params.get(253))
|
||||
if code is None:
|
||||
return None
|
||||
name = OPERATION_NAMES.get(code)
|
||||
if name is None:
|
||||
return None
|
||||
return GameMessage(name, code, message.params)
|
||||
return None
|
||||
|
||||
|
||||
EVENT_NAMES = {
|
||||
EVENT_LEAVE: 'Leave',
|
||||
EVENT_HEALTH_UPDATE: 'HealthUpdate',
|
||||
EVENT_NEW_CHARACTER: 'NewCharacter',
|
||||
EVENT_ITEM_GAINED: 'ItemGained',
|
||||
EVENT_UPDATE_FAME: 'UpdateFame',
|
||||
EVENT_CHARACTER_EQUIPMENT_CHANGED: 'CharacterEquipmentChanged',
|
||||
EVENT_REGENERATION_HEALTH_CHANGED: 'RegenerationHealthChanged',
|
||||
EVENT_SILVER_GAINED: 'SilverGained',
|
||||
EVENT_KNOCKED_DOWN: 'KnockedDown',
|
||||
EVENT_PARTY_INVITATION: 'PartyInvitation',
|
||||
EVENT_PARTY_JOIN_REQUEST: 'PartyJoinRequest',
|
||||
EVENT_PARTY_JOINED: 'PartyJoined',
|
||||
EVENT_PARTY_DISBANDED: 'PartyDisbanded',
|
||||
EVENT_PARTY_PLAYER_JOINED: 'PartyPlayerJoined',
|
||||
EVENT_PARTY_CHANGED_ORDER: 'PartyChangedOrder',
|
||||
EVENT_PARTY_PLAYER_LEFT: 'PartyPlayerLeft',
|
||||
}
|
||||
|
||||
OPERATION_NAMES = {
|
||||
OPERATION_JOIN: 'Join',
|
||||
OPERATION_CHANGE_CLUSTER: 'ChangeCluster',
|
||||
}
|
||||
|
||||
|
||||
# Parameter accessors used by the world state machine. Field names follow
|
||||
# aoaddons' messages.json layouts, with the current opcode space from albion-lens.
|
||||
def msg_source(msg: GameMessage) -> int:
|
||||
v = _int(msg.params.get(0))
|
||||
return v if v is not None else 0
|
||||
|
||||
|
||||
def msg_character_name(msg: GameMessage) -> str:
|
||||
v = _string(msg.params.get(2))
|
||||
return v if v is not None else ''
|
||||
|
||||
|
||||
def msg_new_character_name(msg: GameMessage) -> str:
|
||||
v = _string(msg.params.get(1))
|
||||
return v if v is not None else ''
|
||||
|
||||
|
||||
def msg_map_index(msg: GameMessage) -> Optional[str]:
|
||||
return _string(msg.params.get(8))
|
||||
|
||||
|
||||
def msg_target(msg: GameMessage) -> int:
|
||||
v = _int(msg.params.get(6))
|
||||
return v if v is not None else 0
|
||||
|
||||
|
||||
def msg_value(msg: GameMessage) -> float:
|
||||
v = _float(msg.params.get(2))
|
||||
return v if v is not None else 0.0
|
||||
|
||||
|
||||
def msg_items(msg: GameMessage) -> List[int]:
|
||||
return _as_int_list(msg.params.get(2))
|
||||
|
||||
|
||||
def msg_new_character_items(msg: GameMessage) -> List[int]:
|
||||
return _as_int_list(msg.params.get(33))
|
||||
|
||||
|
||||
def msg_regeneration_rate(msg: GameMessage) -> Optional[float]:
|
||||
if 4 not in msg.params:
|
||||
return None
|
||||
return _float(msg.params.get(4))
|
||||
|
||||
|
||||
def msg_total_fame(msg: GameMessage) -> int:
|
||||
v = _int(msg.params.get(1))
|
||||
return v if v is not None else 0
|
||||
|
||||
|
||||
def msg_fame_gained(msg: GameMessage) -> Optional[int]:
|
||||
if 2 not in msg.params:
|
||||
return None
|
||||
return _int(msg.params.get(2))
|
||||
|
||||
|
||||
def msg_collected_item_id(msg: GameMessage) -> Optional[int]:
|
||||
return _int(msg.params.get(1))
|
||||
|
||||
|
||||
def msg_collected_item_quantity(msg: GameMessage) -> Optional[int]:
|
||||
return _int(msg.params.get(2))
|
||||
|
||||
|
||||
def msg_collected_item_value(msg: GameMessage) -> Optional[int]:
|
||||
return _int(msg.params.get(4))
|
||||
|
||||
|
||||
def msg_silver_source_type(msg: GameMessage) -> Optional[int]:
|
||||
return _int(msg.params.get(1))
|
||||
|
||||
|
||||
def msg_silver_amount(msg: GameMessage) -> Optional[int]:
|
||||
return _int(msg.params.get(2))
|
||||
|
||||
|
||||
def msg_party_structures(msg: GameMessage) -> List[List[int]]:
|
||||
out = []
|
||||
for item in msg.params.get(4, []) or []:
|
||||
out.append(_as_int_list(item))
|
||||
return out
|
||||
|
||||
|
||||
def msg_party_names(msg: GameMessage) -> List[str]:
|
||||
out = []
|
||||
for item in msg.params.get(5, []) or []:
|
||||
s = _string(item)
|
||||
if s is not None:
|
||||
out.append(s)
|
||||
return out
|
||||
|
||||
|
||||
def msg_party_structure(msg: GameMessage) -> List[int]:
|
||||
return _as_int_list(msg.params.get(1))
|
||||
|
||||
|
||||
def msg_party_name(msg: GameMessage) -> str:
|
||||
v = _string(msg.params.get(2))
|
||||
return v if v is not None else ''
|
||||
|
||||
|
||||
def msg_party_roster_names_from_params(params: dict) -> List[str]:
|
||||
names = _string_list(params.get(9))
|
||||
if len(names) < 2:
|
||||
return []
|
||||
if any(name.startswith('UNLOCKED_') for name in names):
|
||||
return []
|
||||
return names
|
||||
|
||||
|
||||
def msg_party_roster_names(msg: GameMessage) -> List[str]:
|
||||
return msg_party_roster_names_from_params(msg.params)
|
||||
@@ -0,0 +1,466 @@
|
||||
import logging
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
from .. import environment
|
||||
from . import items as itemdb
|
||||
from . import party_memory
|
||||
from . import translate
|
||||
from .translate import GameMessage
|
||||
|
||||
FIX_POINT = 10000.0
|
||||
FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events
|
||||
SILVER_SOURCE_LOOTED = 54
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class IdCache:
|
||||
"""Maps dynamic (per-session) ids to stable ids and names.
|
||||
|
||||
Mirrors aoaddons src/game/id_cache.rs: ids are assigned sequentially by
|
||||
player name, so reconnecting to a zone keeps the same id for a player.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.dyn_to_static: Dict[int, int] = {}
|
||||
self.static_to_name: Dict[int, str] = {}
|
||||
self.static_to_dyn: Dict[int, int] = {}
|
||||
self.last_id = 0
|
||||
|
||||
def save(self, dynamic_id: int, name: str):
|
||||
if not name:
|
||||
return
|
||||
static_id = self._find_static_id(name)
|
||||
if static_id is not None:
|
||||
old_dyn = self.static_to_dyn.get(static_id)
|
||||
if old_dyn is not None:
|
||||
self.dyn_to_static.pop(old_dyn, None)
|
||||
self.dyn_to_static[dynamic_id] = static_id
|
||||
self.static_to_dyn[static_id] = dynamic_id
|
||||
return
|
||||
static_id = self.last_id
|
||||
self.last_id += 1
|
||||
self.dyn_to_static[dynamic_id] = static_id
|
||||
self.static_to_dyn[static_id] = dynamic_id
|
||||
self.static_to_name[static_id] = name
|
||||
|
||||
def _find_static_id(self, name: str) -> Optional[int]:
|
||||
for sid, sid_name in self.static_to_name.items():
|
||||
if sid_name == name:
|
||||
return sid
|
||||
return None
|
||||
|
||||
def get_static_id(self, dynamic_id: int) -> Optional[int]:
|
||||
return self.dyn_to_static.get(dynamic_id)
|
||||
|
||||
def get_name(self, static_id: int) -> Optional[str]:
|
||||
return self.static_to_name.get(static_id)
|
||||
|
||||
|
||||
class Party:
|
||||
"""Tracks party membership from party events (aoaddons src/game/party.rs)."""
|
||||
|
||||
def __init__(self):
|
||||
self.main_player_name: Optional[str] = None
|
||||
self.items: List[dict] = [] # {'name', 'id'}
|
||||
self.last_names: List[str] = []
|
||||
|
||||
def set_main_player_name(self, name: str):
|
||||
self.main_player_name = name
|
||||
|
||||
def _game_event(self) -> dict:
|
||||
self.last_names = _unique_names([item['name'] for item in self.items])
|
||||
return {'name': 'UpdateParty', 'value': {
|
||||
'player_names': self.last_names}}
|
||||
|
||||
def set_names(self, names: List[str]):
|
||||
self.items = [
|
||||
{'name': name, 'id': index}
|
||||
for index, name in enumerate(_unique_names(names))
|
||||
]
|
||||
self.last_names = [item['name'] for item in self.items]
|
||||
|
||||
def joined(self, msg: GameMessage) -> Optional[dict]:
|
||||
structures = translate.msg_party_structures(msg)
|
||||
names = translate.msg_party_names(msg)
|
||||
self.items = []
|
||||
for structure, name in zip(structures, names):
|
||||
self.items.append({'name': name, 'id': _party_id(structure)})
|
||||
return self._game_event()
|
||||
|
||||
def disbanded(self) -> Optional[dict]:
|
||||
self.items = []
|
||||
self.last_names = []
|
||||
return self._game_event()
|
||||
|
||||
def player_left(self, msg: GameMessage) -> Optional[dict]:
|
||||
if self.main_player_name is None:
|
||||
return None
|
||||
structure_id = _party_id(translate.msg_party_structure(msg))
|
||||
party_item = next((i for i in self.items if i['id'] == structure_id), None)
|
||||
if party_item is None:
|
||||
return None
|
||||
if party_item['name'] == self.main_player_name:
|
||||
return self.disbanded()
|
||||
self.items = [i for i in self.items if i['id'] != structure_id]
|
||||
return self._game_event()
|
||||
|
||||
def single_player_joined(self, msg: GameMessage) -> Optional[dict]:
|
||||
self.items.append({
|
||||
'name': translate.msg_party_name(msg),
|
||||
'id': _party_id(translate.msg_party_structure(msg)),
|
||||
})
|
||||
return self._game_event()
|
||||
|
||||
def roster(self, msg: GameMessage) -> Optional[dict]:
|
||||
self.set_names(translate.msg_party_roster_names(msg))
|
||||
return self._game_event()
|
||||
|
||||
def remembered(self, names: List[str]) -> Optional[dict]:
|
||||
self.set_names(names)
|
||||
return self._game_event()
|
||||
|
||||
|
||||
class UnconsumedMessages:
|
||||
"""Buffers messages tagged with a dynamic id whose static id is unknown.
|
||||
|
||||
Replayed once the id is resolved (aoaddons src/game/unconsumed_messages.rs).
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._messages: Dict[int, List[GameMessage]] = {}
|
||||
|
||||
def add(self, dynamic_id: int, msg: GameMessage):
|
||||
self._messages.setdefault(dynamic_id, []).append(msg)
|
||||
|
||||
def get_for_id(self, dynamic_id: int) -> List[GameMessage]:
|
||||
return self._messages.get(dynamic_id, [])
|
||||
|
||||
|
||||
class World:
|
||||
"""Transforms translated game messages into app events (aoaddons world.rs)."""
|
||||
|
||||
def __init__(self, remember_last_party: Optional[bool] = None):
|
||||
self.cache = IdCache()
|
||||
self.party = Party()
|
||||
self.unconsumed_messages = UnconsumedMessages()
|
||||
self.main_player_id: Optional[int] = None
|
||||
self._main_player_joined = False
|
||||
self._fame_totals: Dict[int, int] = {}
|
||||
self._seen_item_pickups = set()
|
||||
self._remember_last_party = (environment.remember_last_party()
|
||||
if remember_last_party is None
|
||||
else remember_last_party)
|
||||
self._remembered_party_names = (party_memory.load_last_party()
|
||||
if self._remember_last_party else [])
|
||||
if self._remember_last_party:
|
||||
logger.debug("remember_last_party enabled; loaded names: %s",
|
||||
self._remembered_party_names)
|
||||
else:
|
||||
logger.debug("remember_last_party disabled; saved party will not autoload")
|
||||
self._zone_candidate_names: List[str] = []
|
||||
self._explicit_party_seen = False
|
||||
self._party_inferred = False
|
||||
|
||||
def transform(self, message: GameMessage) -> List[dict]:
|
||||
if message.name == 'NewCharacter':
|
||||
return self._on_new_character(message)
|
||||
if message.name == 'Join':
|
||||
return self._on_join(message)
|
||||
if message.name == 'ChangeCluster':
|
||||
return self._on_change_cluster(message)
|
||||
if message.name == 'Leave':
|
||||
return self._on_leave(message)
|
||||
if message.name == 'HealthUpdate':
|
||||
return self._on_health_update(message)
|
||||
if message.name == 'RegenerationHealthChanged':
|
||||
return self._on_regeneration(message)
|
||||
if message.name == 'KnockedDown':
|
||||
return self._on_knocked_down(message)
|
||||
if message.name == 'UpdateFame':
|
||||
return self._on_update_fame(message)
|
||||
if message.name == 'ItemGained':
|
||||
return self._on_item_gained(message)
|
||||
if message.name == 'SilverGained':
|
||||
return self._on_silver_gained(message)
|
||||
if message.name == 'CharacterEquipmentChanged':
|
||||
return self._on_character_equipment_changed(message)
|
||||
if message.name == 'PartyJoined':
|
||||
return self._explicit_party_event(self.party.joined(message))
|
||||
if message.name == 'PartyDisbanded':
|
||||
return self._explicit_party_event(self.party.disbanded())
|
||||
if message.name == 'PartyPlayerJoined':
|
||||
return self._explicit_party_event(self.party.single_player_joined(message))
|
||||
if message.name == 'PartyPlayerLeft':
|
||||
return self._explicit_party_event(self.party.player_left(message))
|
||||
if message.name == 'PartyRoster':
|
||||
return self._explicit_party_event(self.party.roster(message))
|
||||
return []
|
||||
|
||||
def _party_event(self, event: Optional[dict]) -> List[dict]:
|
||||
return [event] if event is not None else []
|
||||
|
||||
def _explicit_party_event(self, event: Optional[dict]) -> List[dict]:
|
||||
self._explicit_party_seen = True
|
||||
self._party_inferred = False
|
||||
self._remember_party_event(event)
|
||||
return self._party_event(event)
|
||||
|
||||
def _on_new_character(self, msg: GameMessage) -> List[dict]:
|
||||
name = translate.msg_new_character_name(msg)
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
if not name:
|
||||
return []
|
||||
self.cache.save(dynamic_id, name)
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
result = [{
|
||||
'name': 'PlayerAppeared',
|
||||
'value': {'id': static_id, 'name': name},
|
||||
}]
|
||||
result.extend(self._infer_party_from_zone_name(name))
|
||||
items = itemdb.decode_items(translate.msg_new_character_items(msg))
|
||||
if items:
|
||||
result.append({
|
||||
'name': 'UpdateItems',
|
||||
'value': {'source': static_id, 'value': items},
|
||||
})
|
||||
result.extend(self._replay(dynamic_id))
|
||||
if self.main_player_id is None:
|
||||
self.main_player_id = static_id
|
||||
return result
|
||||
|
||||
def _on_join(self, msg: GameMessage) -> List[dict]:
|
||||
name = translate.msg_character_name(msg)
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
if not name:
|
||||
return []
|
||||
self.cache.save(dynamic_id, name)
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
self.party.set_main_player_name(name)
|
||||
result = []
|
||||
if not self._main_player_joined:
|
||||
result.append({'name': 'ZoneChange'})
|
||||
self.main_player_id = static_id
|
||||
self._main_player_joined = True
|
||||
self._zone_candidate_names = _unique_names(self._zone_candidate_names + [name])
|
||||
self._explicit_party_seen = False
|
||||
self._party_inferred = False
|
||||
self._seen_item_pickups.clear()
|
||||
result.append({
|
||||
'name': 'MainPlayerAppeared',
|
||||
'value': {'id': static_id, 'name': name},
|
||||
})
|
||||
result.extend(self._remembered_party_events(name))
|
||||
result.extend(self._infer_party_from_zone_name(name))
|
||||
result.extend(self._replay(dynamic_id))
|
||||
return result
|
||||
|
||||
def _on_change_cluster(self, msg: GameMessage) -> List[dict]:
|
||||
if self.main_player_id is None:
|
||||
return []
|
||||
self._reset_zone_party_inference()
|
||||
self._seen_item_pickups.clear()
|
||||
return [{'name': 'ZoneChange'}]
|
||||
|
||||
def _on_leave(self, msg: GameMessage) -> List[dict]:
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
if self.main_player_id == static_id:
|
||||
self.main_player_id = None
|
||||
self._main_player_joined = False
|
||||
self._reset_zone_party_inference()
|
||||
self._seen_item_pickups.clear()
|
||||
return [{'name': 'ZoneChange'}]
|
||||
return []
|
||||
|
||||
def _on_health_update(self, msg: GameMessage) -> List[dict]:
|
||||
# params: [0]=target (entity whose health changed), [2]=signed delta,
|
||||
# [6]=source (attacker/healer). aoaddons emits Damage{source: params[6],
|
||||
# target: params[0]} which the app attributes to the dealer/healer.
|
||||
value = translate.msg_value(msg)
|
||||
if value == 0.0:
|
||||
return []
|
||||
actor_id = _dyn(translate.msg_target(msg)) # param 6
|
||||
victim_id = _dyn(translate.msg_source(msg)) # param 0
|
||||
actor_static = self.cache.get_static_id(actor_id)
|
||||
if actor_static is None:
|
||||
return []
|
||||
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived'
|
||||
return [{
|
||||
'name': event_name,
|
||||
'value': {'source': actor_static,
|
||||
'target': self.cache.get_static_id(victim_id),
|
||||
'value': float(abs(value))},
|
||||
}]
|
||||
|
||||
def _on_regeneration(self, msg: GameMessage) -> List[dict]:
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
name = self.cache.get_name(static_id) or ''
|
||||
if not name:
|
||||
return []
|
||||
event_name = ('LeaveCombat' if translate.msg_regeneration_rate(msg) is not None
|
||||
else 'EnterCombat')
|
||||
return [{'name': event_name, 'value': {'id': static_id, 'name': name}}]
|
||||
|
||||
def _on_knocked_down(self, msg: GameMessage) -> List[dict]:
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
name = self.cache.get_name(static_id) or ''
|
||||
if not name:
|
||||
return []
|
||||
return [{'name': 'LeaveCombat', 'value': {'id': static_id, 'name': name}}]
|
||||
|
||||
def _on_update_fame(self, msg: GameMessage) -> List[dict]:
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
return []
|
||||
total = translate.msg_total_fame(msg)
|
||||
if total < FAME_MIN_TOTAL:
|
||||
return []
|
||||
prev = self._fame_totals.get(static_id)
|
||||
if prev == total:
|
||||
return []
|
||||
gained = translate.msg_fame_gained(msg)
|
||||
self._fame_totals[static_id] = total
|
||||
if gained is None:
|
||||
if prev is None or total < prev:
|
||||
return []
|
||||
gained = total - prev
|
||||
if gained <= 0:
|
||||
return []
|
||||
return [{'name': 'UpdateFame', 'value': {'value': float(gained / FIX_POINT)}}]
|
||||
|
||||
def _on_item_gained(self, msg: GameMessage) -> List[dict]:
|
||||
if not self._main_player_joined:
|
||||
return []
|
||||
source_id = _dyn(translate.msg_source(msg))
|
||||
item_id = translate.msg_collected_item_id(msg)
|
||||
quantity = translate.msg_collected_item_quantity(msg)
|
||||
if item_id is None or quantity is None or quantity <= 0:
|
||||
return []
|
||||
pickup_key = (source_id, item_id, quantity)
|
||||
if pickup_key in self._seen_item_pickups:
|
||||
return []
|
||||
self._seen_item_pickups.add(pickup_key)
|
||||
item_name = itemdb.display_name(item_id)
|
||||
value = {
|
||||
'item_id': item_id,
|
||||
'item_name': item_name,
|
||||
'quantity': quantity,
|
||||
}
|
||||
estimated_value = translate.msg_collected_item_value(msg)
|
||||
if estimated_value is not None:
|
||||
value['estimated_value'] = estimated_value
|
||||
return [{'name': 'ItemCollected', 'value': value}]
|
||||
|
||||
def _on_silver_gained(self, msg: GameMessage) -> List[dict]:
|
||||
if not self._main_player_joined:
|
||||
return []
|
||||
amount = translate.msg_silver_amount(msg)
|
||||
source_type = translate.msg_silver_source_type(msg)
|
||||
if amount is None or amount <= 0:
|
||||
return []
|
||||
if source_type == SILVER_SOURCE_LOOTED:
|
||||
silver_type = 'looted'
|
||||
else:
|
||||
return []
|
||||
return [{'name': 'SilverGained', 'value': {
|
||||
'value': float(amount),
|
||||
'silver_type': silver_type,
|
||||
}}]
|
||||
|
||||
def _on_character_equipment_changed(self, msg: GameMessage) -> List[dict]:
|
||||
dynamic_id = _dyn(translate.msg_source(msg))
|
||||
static_id = self.cache.get_static_id(dynamic_id)
|
||||
if static_id is None:
|
||||
self.unconsumed_messages.add(dynamic_id, msg)
|
||||
return []
|
||||
items = itemdb.decode_items(translate.msg_items(msg))
|
||||
return [{'name': 'UpdateItems', 'value': {'source': static_id, 'value': items}}]
|
||||
|
||||
def _replay(self, dynamic_id: int) -> List[dict]:
|
||||
result: List[dict] = []
|
||||
for msg in self.unconsumed_messages.get_for_id(dynamic_id):
|
||||
result.extend(self.transform(msg))
|
||||
return result
|
||||
|
||||
def _remembered_party_events(self, main_player_name: str) -> List[dict]:
|
||||
if not self._remember_last_party or not self._remembered_party_names:
|
||||
return []
|
||||
if main_player_name not in self._remembered_party_names:
|
||||
return []
|
||||
event = self.party.remembered(self._remembered_party_names)
|
||||
return self._party_event(event)
|
||||
|
||||
def _infer_party_from_zone_name(self, name: str) -> List[dict]:
|
||||
if not self._remember_last_party or self._explicit_party_seen:
|
||||
return []
|
||||
if name:
|
||||
self._zone_candidate_names = _unique_names(
|
||||
self._zone_candidate_names + [name])
|
||||
if not self._main_player_joined:
|
||||
return []
|
||||
if self.party.last_names and not self._party_inferred:
|
||||
return []
|
||||
if self._remembered_party_names and not self._party_inferred:
|
||||
names = [n for n in self._remembered_party_names
|
||||
if n in self._zone_candidate_names]
|
||||
if self.party.main_player_name in self._remembered_party_names:
|
||||
names = self._remembered_party_names
|
||||
else:
|
||||
names = self._zone_candidate_names
|
||||
if len(names) < 2 or len(names) > 5:
|
||||
return []
|
||||
event = self.party.remembered(names)
|
||||
self._party_inferred = True
|
||||
self._remember_party_event(event)
|
||||
return self._party_event(event)
|
||||
|
||||
def _remember_party_event(self, event: Optional[dict]):
|
||||
if event is None:
|
||||
return
|
||||
names = event.get('value', {}).get('player_names', [])
|
||||
remembered_names = _unique_names(names)
|
||||
if remembered_names:
|
||||
self._remembered_party_names = remembered_names
|
||||
party_memory.save_last_party(remembered_names)
|
||||
elif self._remember_last_party:
|
||||
self._remembered_party_names = []
|
||||
logger.debug("empty party event cleared in-memory party only")
|
||||
|
||||
def _reset_zone_party_inference(self):
|
||||
self._zone_candidate_names = []
|
||||
self._explicit_party_seen = False
|
||||
self._party_inferred = False
|
||||
self.party.items = []
|
||||
self.party.last_names = []
|
||||
|
||||
|
||||
def _dyn(value) -> int:
|
||||
return int(value) & 0xFFFFFFFF
|
||||
|
||||
|
||||
def _party_id(party_structure: List[int]) -> int:
|
||||
return sum(party_structure)
|
||||
|
||||
|
||||
def _unique_names(names: List[str]) -> List[str]:
|
||||
out = []
|
||||
seen = set()
|
||||
for name in names:
|
||||
if not name or name in seen:
|
||||
continue
|
||||
seen.add(name)
|
||||
out.append(name)
|
||||
return out
|
||||
+87
-7
@@ -1,3 +1,4 @@
|
||||
import logging
|
||||
from typing import Iterable
|
||||
from dataclasses import dataclass
|
||||
from queue import Queue
|
||||
@@ -8,12 +9,15 @@ 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 .stats import combat_stats, economy_stats, fame_stats, time_stats, combat_state
|
||||
from .consts import events as ev_consts
|
||||
from .event_receiver import VisibilityEventReceiver
|
||||
from .stats.visibility import Visibility
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class VisibilityType:
|
||||
LastFight: str = 'last_fight'
|
||||
@@ -26,6 +30,7 @@ class StatType:
|
||||
Combat: str = 'Combat'
|
||||
Fame: str = 'Fame'
|
||||
Time: str = 'Time'
|
||||
Economy: str = 'Economy'
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
@@ -42,16 +47,19 @@ class GameStats():
|
||||
StatType.Combat: combat_stats.CombatStats(self.visibility),
|
||||
StatType.Fame: fame_stats.FameStats(),
|
||||
StatType.Time: time_stats.TimeStats(),
|
||||
StatType.Economy: economy_stats.EconomyStats(),
|
||||
}
|
||||
self.last_fight = {
|
||||
StatType.Combat: combat_stats.CombatStats(self.visibility),
|
||||
StatType.Fame: fame_stats.FameStats(),
|
||||
StatType.Time: time_stats.TimeStats(),
|
||||
StatType.Economy: economy_stats.EconomyStats(),
|
||||
}
|
||||
self.history = {
|
||||
StatType.Combat: combat_stats.CombatStats(self.visibility),
|
||||
StatType.Fame: fame_stats.FameStats(),
|
||||
StatType.Time: time_stats.TimeStats(),
|
||||
StatType.Economy: economy_stats.EconomyStats(),
|
||||
}
|
||||
|
||||
def register_event(self, event):
|
||||
@@ -64,6 +72,7 @@ class GameStats():
|
||||
self.zone[StatType.Combat])
|
||||
self.history[StatType.Fame].update(self.zone[StatType.Fame])
|
||||
self.history[StatType.Time].update(self.zone[StatType.Time])
|
||||
self.history[StatType.Economy].update(self.zone[StatType.Economy])
|
||||
|
||||
self._construct_new_stats([VisibilityType.Zone])
|
||||
|
||||
@@ -71,11 +80,13 @@ class GameStats():
|
||||
self.last_fight[StatType.Combat].receive(event)
|
||||
self.zone[StatType.Fame].receive(event)
|
||||
self.last_fight[StatType.Fame].receive(event)
|
||||
self.zone[StatType.Economy].receive(event)
|
||||
self.last_fight[StatType.Economy].receive(event)
|
||||
self.visibility.receive(event)
|
||||
|
||||
def reset(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
for t in (StatType.Combat, StatType.Time, StatType.Fame):
|
||||
for t in (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy):
|
||||
self.history[t].update(self.zone[t])
|
||||
self._construct_new_stats(
|
||||
(VisibilityType.Zone, VisibilityType.LastFight))
|
||||
@@ -101,6 +112,14 @@ class GameStats():
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_healing()
|
||||
|
||||
def get_total_healing_stats(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
return self.zone[StatType.Combat].players_total_healing()
|
||||
elif stat_type == VisibilityType.LastFight:
|
||||
return self.last_fight[StatType.Combat].players_total_healing()
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_total_healing()
|
||||
|
||||
def fame_stats(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
return self.zone[StatType.Fame].stats()
|
||||
@@ -117,8 +136,32 @@ class GameStats():
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Time].combined(self.zone[StatType.Time]).stats()
|
||||
|
||||
def economy_stats(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
return self.zone[StatType.Economy].stats()
|
||||
elif stat_type == VisibilityType.LastFight:
|
||||
return self.last_fight[StatType.Economy].stats()
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).stats()
|
||||
|
||||
def item_stats(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
return self.zone[StatType.Economy].item_list()
|
||||
elif stat_type == VisibilityType.LastFight:
|
||||
return self.last_fight[StatType.Economy].item_list()
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).item_list()
|
||||
|
||||
def silver_stats(self, stat_type):
|
||||
if stat_type == VisibilityType.Zone:
|
||||
return self.zone[StatType.Economy].silver_list()
|
||||
elif stat_type == VisibilityType.LastFight:
|
||||
return self.last_fight[StatType.Economy].silver_list()
|
||||
elif stat_type == VisibilityType.Overall:
|
||||
return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).silver_list()
|
||||
|
||||
def _construct_new_stats(self, scope: Iterable[str]):
|
||||
types = (StatType.Combat, StatType.Time, StatType.Fame)
|
||||
types = (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy)
|
||||
for s in scope:
|
||||
for t in types:
|
||||
if t == StatType.Time:
|
||||
@@ -128,6 +171,8 @@ class GameStats():
|
||||
getattr(self, s)[t])
|
||||
elif t == StatType.Fame:
|
||||
getattr(self, s)[t] = fame_stats.FameStats()
|
||||
elif t == StatType.Economy:
|
||||
getattr(self, s)[t] = economy_stats.EconomyStats()
|
||||
|
||||
|
||||
game_stats = GameStats()
|
||||
@@ -152,18 +197,34 @@ def last_fight_stats(combat_stat_type: str):
|
||||
return get_stats(VisibilityType.LastFight, combat_stat_type)
|
||||
|
||||
|
||||
def zone_total_healing_stats():
|
||||
return game_stats.get_total_healing_stats(VisibilityType.Zone)
|
||||
|
||||
|
||||
def overall_total_healing_stats():
|
||||
return game_stats.get_total_healing_stats(VisibilityType.Overall)
|
||||
|
||||
|
||||
def last_fight_total_healing_stats():
|
||||
return game_stats.get_total_healing_stats(VisibilityType.LastFight)
|
||||
|
||||
|
||||
cached_players = () # do not compute values if there is nothing in queue
|
||||
cached_stat_type = None
|
||||
cached_combat_stat_type = None
|
||||
|
||||
|
||||
def get_stats(stat_type: str, combat_stat_type: str):
|
||||
global cached_players, cached_stat_type, cached_combat_stat_type
|
||||
def _drain_events():
|
||||
new_events = False
|
||||
|
||||
while not event_queue.empty():
|
||||
new_events = True
|
||||
game_stats.register_event(event_queue.get_nowait())
|
||||
return new_events
|
||||
|
||||
|
||||
def get_stats(stat_type: str, combat_stat_type: str):
|
||||
global cached_players, cached_stat_type, cached_combat_stat_type
|
||||
new_events = _drain_events()
|
||||
|
||||
fame = game_stats.fame_stats(stat_type)
|
||||
time = game_stats.time_stats(stat_type)['seconds_in_game']
|
||||
@@ -185,8 +246,24 @@ def get_stats(stat_type: str, combat_stat_type: str):
|
||||
return (cached_players, fame, time)
|
||||
|
||||
|
||||
def economy_stats_for(stat_type: str):
|
||||
_drain_events()
|
||||
return game_stats.economy_stats(stat_type)
|
||||
|
||||
|
||||
def item_stats_for(stat_type: str):
|
||||
_drain_events()
|
||||
return game_stats.item_stats(stat_type)
|
||||
|
||||
|
||||
def silver_stats_for(stat_type: str):
|
||||
_drain_events()
|
||||
return game_stats.silver_stats(stat_type)
|
||||
|
||||
|
||||
def queue_an_event(event):
|
||||
event_queue.put(event)
|
||||
logger.debug("event received: %s", event.get(ev_consts.EvKeyName))
|
||||
|
||||
|
||||
def reset_zone_stats():
|
||||
@@ -207,5 +284,8 @@ def is_ready():
|
||||
|
||||
def initialize():
|
||||
initialization_result = backend_proxy.initialize()
|
||||
backend_proxy.subscribe(queue_an_event)
|
||||
if not backend_proxy.subscribe(queue_an_event):
|
||||
logger.error("packet capture backend subscription failed")
|
||||
if initialization_result == InitializationResult.Ok:
|
||||
return InitializationResult.UnknownFailure
|
||||
return initialization_result
|
||||
|
||||
+130
-2
@@ -1,7 +1,136 @@
|
||||
import faulthandler
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
from typing import List, Optional
|
||||
|
||||
TEST_ENV_ENABLED = bool(os.getenv('TESTING'))
|
||||
|
||||
# Verbose debugging flag, e.g. ``aostats --verbose``.
|
||||
VERBOSE = bool(
|
||||
os.getenv('AOSTATS_VERBOSE') or
|
||||
'--verbose' in sys.argv or
|
||||
'-v' in sys.argv
|
||||
)
|
||||
|
||||
|
||||
def _arg_value(name: str) -> Optional[str]:
|
||||
prefix = name + '='
|
||||
for i, arg in enumerate(sys.argv):
|
||||
if arg.startswith(prefix):
|
||||
return arg[len(prefix):]
|
||||
if arg == name and i + 1 < len(sys.argv):
|
||||
return sys.argv[i + 1]
|
||||
return None
|
||||
|
||||
|
||||
DISCOVERY_LOG_PATH = (
|
||||
os.getenv('AOSTATS_LOG_PATH') or
|
||||
_arg_value('--log-path')
|
||||
)
|
||||
|
||||
REMEMBER_LAST_PARTY = bool(
|
||||
os.getenv('AOSTATS_REMEMBER_LAST_PARTY') or
|
||||
'--remember-last-party' in sys.argv
|
||||
)
|
||||
|
||||
_fault_file = None
|
||||
|
||||
|
||||
def is_verbose():
|
||||
return VERBOSE
|
||||
|
||||
|
||||
def discovery_log_path():
|
||||
return DISCOVERY_LOG_PATH
|
||||
|
||||
|
||||
def remember_last_party():
|
||||
return REMEMBER_LAST_PARTY
|
||||
|
||||
|
||||
def app_log_path() -> Optional[str]:
|
||||
if not DISCOVERY_LOG_PATH:
|
||||
return None
|
||||
return DISCOVERY_LOG_PATH + '.app.log'
|
||||
|
||||
|
||||
def qt_args(argv: List[str]) -> List[str]:
|
||||
"""Return argv with app-specific options removed before Qt sees them."""
|
||||
result = []
|
||||
skip_next = False
|
||||
for arg in argv:
|
||||
if skip_next:
|
||||
skip_next = False
|
||||
continue
|
||||
if arg in ('--verbose', '-v'):
|
||||
continue
|
||||
if arg == '--log-path':
|
||||
skip_next = True
|
||||
continue
|
||||
if arg.startswith('--log-path='):
|
||||
continue
|
||||
if arg == '--remember-last-party':
|
||||
continue
|
||||
result.append(arg)
|
||||
return result
|
||||
|
||||
|
||||
def setup_logging():
|
||||
"""Enable verbose logging for the app and the packet capture backend.
|
||||
|
||||
The Rust backend reads the ``BACKEND_LOG_LEVEL`` environment variable when
|
||||
it initializes, so it must be set before ``initialize()`` is called.
|
||||
"""
|
||||
if not VERBOSE:
|
||||
return
|
||||
|
||||
os.environ['BACKEND_LOG_LEVEL'] = 'debug'
|
||||
|
||||
handlers = [logging.StreamHandler()]
|
||||
if DISCOVERY_LOG_PATH:
|
||||
log_dir = os.path.dirname(DISCOVERY_LOG_PATH)
|
||||
if log_dir:
|
||||
os.makedirs(log_dir, exist_ok=True)
|
||||
handlers.append(logging.FileHandler(app_log_path()))
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.DEBUG,
|
||||
format='%(asctime)s %(levelname)-8s %(name)s: %(message)s',
|
||||
datefmt='%H:%M:%S',
|
||||
handlers=handlers)
|
||||
|
||||
_install_crash_diagnostics()
|
||||
|
||||
|
||||
def _install_crash_diagnostics():
|
||||
global _fault_file
|
||||
log_path = app_log_path()
|
||||
_fault_file = None
|
||||
if log_path:
|
||||
_fault_file = open(log_path, 'a')
|
||||
faulthandler.enable(file=_fault_file, all_threads=True)
|
||||
else:
|
||||
faulthandler.enable(all_threads=True)
|
||||
|
||||
for sig_name in ('SIGSEGV', 'SIGABRT', 'SIGBUS', 'SIGFPE'):
|
||||
sig = getattr(signal, sig_name, None)
|
||||
if sig is None:
|
||||
continue
|
||||
try:
|
||||
faulthandler.register(sig, file=_fault_file, all_threads=True,
|
||||
chain=True)
|
||||
except (RuntimeError, ValueError, OSError):
|
||||
pass
|
||||
|
||||
def excepthook(exc_type, exc, tb):
|
||||
logging.getLogger(__name__).critical(
|
||||
"unhandled exception", exc_info=(exc_type, exc, tb))
|
||||
sys.__excepthook__(exc_type, exc, tb)
|
||||
|
||||
sys.excepthook = excepthook
|
||||
|
||||
|
||||
class TestType:
|
||||
Simple = 'simple'
|
||||
@@ -19,7 +148,6 @@ 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())))
|
||||
raise Exception(f'Unavailable GUI test type: {test_type}, avaliable values: {",".join(_test_types.keys())}')
|
||||
|
||||
TEST_TYPE = _test_types[test_type.lower()]
|
||||
|
||||
@@ -44,6 +44,26 @@ class FameEventReceiver(EventReceiver):
|
||||
pass
|
||||
|
||||
|
||||
class EconomyEventReceiver(EventReceiver):
|
||||
|
||||
def on_event(self, event_name: str, value: dict):
|
||||
if event_name == consts.EvNameSilverGained:
|
||||
self.on_silver_gained(
|
||||
value[consts.EvKeyValue], value[consts.EvKeySilverType])
|
||||
elif event_name == consts.EvNameItemCollected:
|
||||
self.on_item_collected(
|
||||
value[consts.EvKeyItemId], value[consts.EvKeyItemName],
|
||||
value[consts.EvKeyQuantity])
|
||||
|
||||
@abc.abstractmethod
|
||||
def on_silver_gained(self, value: float, silver_type: str):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def on_item_collected(self, item_id: int, item_name: str, quantity: int):
|
||||
pass
|
||||
|
||||
|
||||
class CombatEventReceiver(EventReceiver):
|
||||
|
||||
def on_event(self, event_name: str, value: dict):
|
||||
|
||||
+117
-19
@@ -1,18 +1,25 @@
|
||||
import logging
|
||||
import os
|
||||
import platform
|
||||
import subprocess
|
||||
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
|
||||
try:
|
||||
import resource
|
||||
except ImportError: # pragma: no cover - Windows fallback
|
||||
resource = None
|
||||
|
||||
from PySide6 import QtCore # type: ignore
|
||||
from PySide6.QtCore import Qt # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
from PySide6.QtWidgets import QApplication # type: ignore
|
||||
from PySide6.QtWidgets import QMessageBox # type: ignore
|
||||
from PySide6.QtWidgets import QPushButton # type: ignore
|
||||
|
||||
from ..engine import InitializationResult
|
||||
from ..engine import initialize
|
||||
from ..utils.config import config
|
||||
from ..environment import is_verbose, qt_args, remember_last_party, setup_logging
|
||||
|
||||
from .modules.main import MainWidget
|
||||
from .styling import style
|
||||
@@ -20,17 +27,63 @@ from ..utils.version import current_version as get_current_version
|
||||
from ..utils.version import latest_version as get_latest_version
|
||||
from ..utils.assets import path
|
||||
from ..utils.assets import scripts
|
||||
from ..utils import platform_utils
|
||||
from ..utils.platform_utils import capture_permissions_ok
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.abspath('__file__')))
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _qt_message_handler(mode, context, message):
|
||||
logger.debug("qt message[%s] %s:%s %s", mode, context.file,
|
||||
context.line, message)
|
||||
|
||||
|
||||
def _install_heartbeat(app):
|
||||
if not is_verbose():
|
||||
return
|
||||
timer = QtCore.QTimer(app)
|
||||
|
||||
def heartbeat():
|
||||
rss_kb = (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
|
||||
if resource else None)
|
||||
logger.debug("heartbeat pid=%s rss_kb=%s", os.getpid(), rss_kb)
|
||||
|
||||
timer.timeout.connect(heartbeat)
|
||||
timer.start(10000)
|
||||
app._aostats_heartbeat_timer = timer
|
||||
|
||||
|
||||
def fix_network():
|
||||
script_name = platform_utils.repair_script()
|
||||
if not script_name:
|
||||
sys.exit(0)
|
||||
|
||||
script_path = scripts(script_name)
|
||||
|
||||
if platform_utils.is_windows():
|
||||
os.system(script_path)
|
||||
else:
|
||||
subprocess.call(['sh', script_path, sys.executable])
|
||||
|
||||
def fix_npcap():
|
||||
os.system(scripts('fixnpcap.bat'))
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
def run():
|
||||
setup_logging()
|
||||
|
||||
app_argv = qt_args(sys.argv)
|
||||
|
||||
logger.info("Albion Online Stats v%s starting", get_current_version())
|
||||
logger.debug("pid: %s", os.getpid())
|
||||
logger.debug("argv: %s", sys.argv)
|
||||
logger.debug("remember_last_party: %s", remember_last_party())
|
||||
logger.debug("python: %s (%s)", sys.executable, sys.version)
|
||||
logger.debug("platform: %s", platform_utils.system())
|
||||
|
||||
initialization_result = initialize()
|
||||
logger.debug("backend initialization result: %s", initialization_result)
|
||||
|
||||
conf = config()
|
||||
window_config = conf['window']
|
||||
@@ -38,17 +91,21 @@ def run():
|
||||
WIDTH = window_config['width']
|
||||
HEIGHT = window_config['height']
|
||||
|
||||
app = QApplication(sys.argv)
|
||||
perms_ok = True
|
||||
if platform_utils.is_linux():
|
||||
perms_ok = capture_permissions_ok()
|
||||
logger.debug("capture permissions probe: %s", perms_ok)
|
||||
|
||||
app = QApplication(app_argv)
|
||||
QtCore.qInstallMessageHandler(_qt_message_handler)
|
||||
_install_heartbeat(app)
|
||||
|
||||
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')))
|
||||
@@ -58,6 +115,10 @@ def run():
|
||||
if window_config['frameless']:
|
||||
widget.setWindowFlag(Qt.FramelessWindowHint)
|
||||
|
||||
if window_config.get('fullscreen', True):
|
||||
widget.showMaximized()
|
||||
else:
|
||||
widget.resize(WIDTH, HEIGHT)
|
||||
widget.show()
|
||||
|
||||
current_version, latest_version = (
|
||||
@@ -73,20 +134,57 @@ def run():
|
||||
msg.setStandardButtons(QMessageBox.Ok)
|
||||
msg.show()
|
||||
|
||||
if initialization_result == InitializationResult.NetworkInterfaceListMissing:
|
||||
need_capture_fix = (
|
||||
initialization_result != InitializationResult.Ok
|
||||
or (platform_utils.is_linux() and not perms_ok)
|
||||
)
|
||||
|
||||
if need_capture_fix:
|
||||
msg = QMessageBox()
|
||||
msg.setIcon(QMessageBox.Critical)
|
||||
msg.setWindowTitle("Unable to track network traffic data!")
|
||||
|
||||
if initialization_result == InitializationResult.BackendNotInstalled:
|
||||
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>\
|
||||
"The packet capture backend (pyaoaddons) is not installed.")
|
||||
msg.setInformativeText(
|
||||
"pyaoaddons 0.2.8 ships prebuilt wheels only for CPython 3.6-3.10.<br>\
|
||||
Use one of those Python versions and reinstall the app \
|
||||
(<code>python -m pip install .</code>), or build pyaoaddons from source.<br><br>\
|
||||
See the README for details.")
|
||||
msg.setStandardButtons(QMessageBox.Ok)
|
||||
elif platform_utils.is_windows():
|
||||
msg.setText(
|
||||
"On Windows make sure that Npcap is installed in your system.")
|
||||
msg.setInformativeText("Npcap 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)
|
||||
button.clicked.connect(fix_network)
|
||||
msg.addButton(button, QMessageBox.NoRole)
|
||||
else:
|
||||
permissions_missing = platform_utils.is_linux() and not perms_ok
|
||||
if permissions_missing:
|
||||
msg.setText(
|
||||
"The app does not have permission to capture network packets.")
|
||||
msg.setInformativeText(
|
||||
"Capturing packets requires elevated privileges. Use the button below \
|
||||
to grant the Python interpreter the needed capabilities \
|
||||
(or run the app with <code>sudo</code>).")
|
||||
else:
|
||||
msg.setText(
|
||||
"Make sure that libpcap is installed and network interfaces are available.")
|
||||
msg.setInformativeText(
|
||||
"Install libpcap:<br>\
|
||||
<b>Debian/Ubuntu:</b> <code>sudo apt install libpcap0.8</code><br>\
|
||||
<b>Fedora:</b> <code>sudo dnf install libpcap</code><br>\
|
||||
<b>Arch:</b> <code>sudo pacman -S libpcap</code>")
|
||||
msg.setStandardButtons(QMessageBox.Ok)
|
||||
if platform_utils.repair_script():
|
||||
button = QPushButton("Fix capture permissions")
|
||||
button.clicked.connect(fix_network)
|
||||
msg.addButton(button, QMessageBox.NoRole)
|
||||
msg.show()
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
from PySide2.QtWidgets import QMessageBox # noqa type: ignore
|
||||
from PySide6.QtWidgets import QMessageBox # noqa type: ignore
|
||||
|
||||
from ...utils.version import get_version
|
||||
|
||||
|
||||
+413
-101
@@ -1,143 +1,455 @@
|
||||
import sys
|
||||
import functools
|
||||
import sys
|
||||
|
||||
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 PySide6 import QtGui # type: ignore
|
||||
from PySide6.QtCore import Qt # type: ignore
|
||||
from PySide6.QtCore import QTimer # type: ignore
|
||||
from PySide6.QtWidgets import QButtonGroup # type: ignore
|
||||
from PySide6.QtWidgets import QFrame # type: ignore
|
||||
from PySide6.QtWidgets import QGridLayout # type: ignore
|
||||
from PySide6.QtWidgets import QHBoxLayout # type: ignore
|
||||
from PySide6.QtWidgets import QLabel # type: ignore
|
||||
from PySide6.QtWidgets import QListView # type: ignore
|
||||
from PySide6.QtWidgets import QPushButton # type: ignore
|
||||
from PySide6.QtWidgets import QScrollArea # type: ignore
|
||||
from PySide6.QtWidgets import QVBoxLayout # type: ignore
|
||||
from PySide6.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 ...utils.number import Number
|
||||
from . import about
|
||||
from .view_type import ViewType
|
||||
from .views import StatsType
|
||||
from .views.list_view import ListItemView
|
||||
|
||||
|
||||
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 Page:
|
||||
Overview = 'overview'
|
||||
Damage = 'damage'
|
||||
Healing = 'healing'
|
||||
Economy = 'economy'
|
||||
Items = 'items'
|
||||
Settings = 'settings'
|
||||
|
||||
|
||||
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)
|
||||
PAGE_LABELS = {
|
||||
Page.Overview: ('O', 'Overview'),
|
||||
Page.Damage: ('D', 'Damage Done'),
|
||||
Page.Healing: ('H', 'Healing Done'),
|
||||
Page.Economy: ('$', 'Economy'),
|
||||
Page.Items: ('I', 'Items Collected'),
|
||||
Page.Settings: ('S', 'Settings'),
|
||||
}
|
||||
|
||||
|
||||
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()
|
||||
SCOPE_LABELS = {
|
||||
StatsType.ZONE: 'Current Zone',
|
||||
StatsType.LAST_FIGHT: 'Last Fight',
|
||||
StatsType.OVERALL: 'Overall Session',
|
||||
}
|
||||
|
||||
|
||||
class TopBar(QWidget):
|
||||
class Sidebar(QWidget):
|
||||
def __init__(self, on_page_changed, on_scope_changed):
|
||||
QWidget.__init__(self)
|
||||
self.setObjectName('Sidebar')
|
||||
self.expanded = True
|
||||
self.on_page_changed = on_page_changed
|
||||
self.on_scope_changed = on_scope_changed
|
||||
self.page_buttons = {}
|
||||
self.scope_buttons = {}
|
||||
|
||||
self.layout = QVBoxLayout()
|
||||
self.layout.setContentsMargins(14, 14, 14, 14)
|
||||
self.layout.setSpacing(8)
|
||||
|
||||
self.toggle_button = QPushButton('Collapse')
|
||||
self.toggle_button.setObjectName('SidebarToggle')
|
||||
self.toggle_button.clicked.connect(self.toggle)
|
||||
self.layout.addWidget(self.toggle_button)
|
||||
|
||||
self.title = QLabel('AO Stats')
|
||||
self.title.setObjectName('SidebarTitle')
|
||||
self.layout.addWidget(self.title)
|
||||
|
||||
self.page_group = QButtonGroup(self)
|
||||
self.page_group.setExclusive(True)
|
||||
for page, (_short, label) in PAGE_LABELS.items():
|
||||
button = QPushButton(label)
|
||||
button.setCheckable(True)
|
||||
button.clicked.connect(functools.partial(self._select_page, page))
|
||||
self.page_group.addButton(button)
|
||||
self.page_buttons[page] = button
|
||||
self.layout.addWidget(button)
|
||||
|
||||
self.scope_label = QLabel('Scope')
|
||||
self.scope_label.setObjectName('SidebarSection')
|
||||
self.layout.addWidget(self.scope_label)
|
||||
|
||||
self.scope_group = QButtonGroup(self)
|
||||
self.scope_group.setExclusive(True)
|
||||
for scope, label in SCOPE_LABELS.items():
|
||||
button = QPushButton(label)
|
||||
button.setCheckable(True)
|
||||
button.clicked.connect(functools.partial(self._select_scope, scope))
|
||||
self.scope_group.addButton(button)
|
||||
self.scope_buttons[scope] = button
|
||||
self.layout.addWidget(button)
|
||||
|
||||
self.layout.addStretch(1)
|
||||
self.setLayout(self.layout)
|
||||
|
||||
def set_initial(self, page, scope):
|
||||
self.page_buttons[page].setChecked(True)
|
||||
self.scope_buttons[scope].setChecked(True)
|
||||
|
||||
def _select_page(self, page):
|
||||
self.on_page_changed(page)
|
||||
|
||||
def _select_scope(self, scope):
|
||||
self.on_scope_changed(scope)
|
||||
|
||||
def toggle(self):
|
||||
self.expanded = not self.expanded
|
||||
self.setFixedWidth(220 if self.expanded else 72)
|
||||
self.toggle_button.setText('Collapse' if self.expanded else '>>')
|
||||
self.title.setVisible(self.expanded)
|
||||
self.scope_label.setVisible(self.expanded)
|
||||
for page, button in self.page_buttons.items():
|
||||
short, label = PAGE_LABELS[page]
|
||||
button.setText(label if self.expanded else short)
|
||||
for scope, button in self.scope_buttons.items():
|
||||
button.setText(SCOPE_LABELS[scope] if self.expanded else scope[:1])
|
||||
|
||||
|
||||
class StatCard(QFrame):
|
||||
def __init__(self, title):
|
||||
QFrame.__init__(self)
|
||||
self.setObjectName('StatCard')
|
||||
self.layout = QVBoxLayout()
|
||||
self.layout.setContentsMargins(16, 12, 16, 12)
|
||||
self.title = QLabel(title)
|
||||
self.title.setObjectName('CardTitle')
|
||||
self.value = QLabel('0')
|
||||
self.value.setObjectName('CardValue')
|
||||
self.layout.addWidget(self.title)
|
||||
self.layout.addWidget(self.value)
|
||||
self.setLayout(self.layout)
|
||||
|
||||
def update_value(self, value):
|
||||
self.value.setText(str(value))
|
||||
|
||||
|
||||
class HeaderBar(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.layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.title = QLabel('Albion Online Stats')
|
||||
self.title.setObjectName('HeaderTitle')
|
||||
self.status = QLabel('Waiting for zone change')
|
||||
self.status.setObjectName('HeaderStatus')
|
||||
self.layout.addWidget(self.title)
|
||||
self.layout.addStretch(1)
|
||||
self.layout.addWidget(self.status)
|
||||
self.setLayout(self.layout)
|
||||
|
||||
self.about_button = AboutButton()
|
||||
self.layout.addWidget(self.about_button)
|
||||
def update_status(self):
|
||||
if engine.is_ready():
|
||||
self.status.setText('Tracking live Albion Online traffic')
|
||||
else:
|
||||
self.status.setText('Waiting for zone change to identify your character')
|
||||
|
||||
self.close_button = CloseButton(config()['window']['frameless'])
|
||||
self.layout.addWidget(self.close_button)
|
||||
|
||||
class ItemsPanel(QFrame):
|
||||
def __init__(self):
|
||||
QFrame.__init__(self)
|
||||
self.setObjectName('ItemsPanel')
|
||||
self.layout = QVBoxLayout()
|
||||
self.layout.setContentsMargins(16, 16, 16, 16)
|
||||
title = QLabel('Items Collected')
|
||||
title.setObjectName('PanelTitle')
|
||||
self.layout.addWidget(title)
|
||||
self.list = PlainStatsListView()
|
||||
self.layout.addWidget(self.list, 1)
|
||||
self.layout.addStretch(1)
|
||||
self.setLayout(self.layout)
|
||||
|
||||
def update(self, items):
|
||||
self.list.update(items)
|
||||
|
||||
|
||||
class PlainStatsListView(QListView):
|
||||
def __init__(self):
|
||||
QListView.__init__(self)
|
||||
self.model = QtGui.QStandardItemModel(self)
|
||||
self.setModel(self.model)
|
||||
|
||||
def update(self, items):
|
||||
self.model.clear()
|
||||
for item in items:
|
||||
row = QtGui.QStandardItem(
|
||||
f'{item.name} {item.value} ({item.percentage}%)')
|
||||
row.setFlags(row.flags() & ~Qt.ItemIsSelectable)
|
||||
row.setForeground(QtGui.QBrush(QtGui.QColor('#d8dbe2')))
|
||||
self.model.appendRow(row)
|
||||
|
||||
|
||||
class SettingsPanel(QWidget):
|
||||
def __init__(self, clipboard):
|
||||
QWidget.__init__(self)
|
||||
self.clipboard = clipboard
|
||||
self.about = about.About()
|
||||
self.layout = QVBoxLayout()
|
||||
self.layout.setSpacing(12)
|
||||
|
||||
description = QLabel(
|
||||
'Use this page for session actions. Fullscreen dashboard mode is the default; '
|
||||
'set window.fullscreen = false in the config file to use a normal window.')
|
||||
description.setWordWrap(True)
|
||||
description.setObjectName('PageDescription')
|
||||
self.layout.addWidget(description)
|
||||
|
||||
reset_zone = QPushButton('Reset Current Zone')
|
||||
reset_zone.clicked.connect(engine.reset_zone_stats)
|
||||
self.layout.addWidget(reset_zone)
|
||||
|
||||
reset_fight = QPushButton('Reset Last Fight')
|
||||
reset_fight.clicked.connect(engine.reset_last_fight_stats)
|
||||
self.layout.addWidget(reset_fight)
|
||||
|
||||
reset_all = QPushButton('Reset Overall Session')
|
||||
reset_all.clicked.connect(engine.reset_stats)
|
||||
self.layout.addWidget(reset_all)
|
||||
|
||||
about_button = QPushButton('About Albion Online Stats')
|
||||
about_button.clicked.connect(self.about.show)
|
||||
self.layout.addWidget(about_button)
|
||||
|
||||
if not config()['window']['fullscreen']:
|
||||
close_button = QPushButton('Close')
|
||||
close_button.setIcon(QtGui.QIcon(assets.path('close.png')))
|
||||
close_button.clicked.connect(lambda: sys.exit(0))
|
||||
self.layout.addWidget(close_button)
|
||||
|
||||
self.layout.addStretch(1)
|
||||
self.setLayout(self.layout)
|
||||
|
||||
|
||||
class MainWidget(QWidget):
|
||||
def __init__(self, clipboard):
|
||||
QWidget.__init__(self)
|
||||
self.clipboard = clipboard
|
||||
self.current_page = Page.Overview
|
||||
self.current_scope = StatsType.ZONE
|
||||
|
||||
self.mouse_pos = None
|
||||
self.root_layout = QHBoxLayout()
|
||||
self.root_layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.root_layout.setSpacing(0)
|
||||
|
||||
self.layout = QVBoxLayout()
|
||||
self.top_bar = TopBar()
|
||||
self.layout.addWidget(self.top_bar)
|
||||
self.sidebar = Sidebar(self.set_page, self.set_scope)
|
||||
self.sidebar.set_initial(self.current_page, self.current_scope)
|
||||
self.root_layout.addWidget(self.sidebar)
|
||||
|
||||
self.view = ModeBasedListView(clipboard)
|
||||
self.layout.addWidget(self.view)
|
||||
self.main_area = QWidget()
|
||||
self.main_layout = QVBoxLayout()
|
||||
self.main_layout.setContentsMargins(22, 18, 22, 18)
|
||||
self.main_layout.setSpacing(14)
|
||||
self.main_area.setLayout(self.main_layout)
|
||||
|
||||
self.header = HeaderBar()
|
||||
self.main_layout.addWidget(self.header)
|
||||
|
||||
self.cards_layout = QGridLayout()
|
||||
self.cards_layout.setSpacing(12)
|
||||
self.elapsed_card = StatCard('Time in selected scope')
|
||||
self.fame_card = StatCard('Fame gained')
|
||||
self.fph_card = StatCard('Fame per hour')
|
||||
self.ready_card = StatCard('Tracking status')
|
||||
self.cards_layout.addWidget(self.elapsed_card, 0, 0)
|
||||
self.cards_layout.addWidget(self.fame_card, 0, 1)
|
||||
self.cards_layout.addWidget(self.fph_card, 0, 2)
|
||||
self.cards_layout.addWidget(self.ready_card, 0, 3)
|
||||
self.main_layout.addLayout(self.cards_layout)
|
||||
|
||||
self.page_title = QLabel('Overview')
|
||||
self.page_title.setObjectName('PageTitle')
|
||||
self.page_description = QLabel('')
|
||||
self.page_description.setObjectName('PageDescription')
|
||||
self.page_description.setWordWrap(True)
|
||||
self.main_layout.addWidget(self.page_title)
|
||||
self.main_layout.addWidget(self.page_description)
|
||||
|
||||
self.primary_label = QLabel('')
|
||||
self.primary_label.setObjectName('PanelTitle')
|
||||
self.main_layout.addWidget(self.primary_label)
|
||||
|
||||
self.primary_list = ListItemView()
|
||||
self.main_layout.addWidget(self.primary_list, 1)
|
||||
|
||||
self.plain_list = PlainStatsListView()
|
||||
self.main_layout.addWidget(self.plain_list, 1)
|
||||
|
||||
self.total_healing_label = QLabel('Total Healing')
|
||||
self.total_healing_label.setObjectName('PanelTitle')
|
||||
self.total_healing_list = ListItemView()
|
||||
self.main_layout.addWidget(self.total_healing_label)
|
||||
self.main_layout.addWidget(self.total_healing_list, 1)
|
||||
|
||||
self.placeholder = QLabel('')
|
||||
self.placeholder.setObjectName('MutedText')
|
||||
self.placeholder.setWordWrap(True)
|
||||
self.main_layout.addWidget(self.placeholder, 1)
|
||||
|
||||
self.settings_panel = SettingsPanel(clipboard)
|
||||
self.main_layout.addWidget(self.settings_panel, 1)
|
||||
|
||||
self.root_layout.addWidget(self.main_area, 1)
|
||||
self.items_panel = ItemsPanel()
|
||||
self.root_layout.addWidget(self.items_panel)
|
||||
self.setLayout(self.root_layout)
|
||||
|
||||
self.setLayout(self.layout)
|
||||
self.refresh()
|
||||
|
||||
timer = QTimer(self)
|
||||
timer.timeout.connect(self.refresh)
|
||||
timer.start(500)
|
||||
|
||||
def set_page(self, page):
|
||||
self.current_page = page
|
||||
self.refresh()
|
||||
|
||||
def set_scope(self, scope):
|
||||
self.current_scope = scope
|
||||
self.refresh()
|
||||
|
||||
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
|
||||
)
|
||||
players, fame_stat, elapsed = self.primary_stats()
|
||||
total_healing = self.total_healing_stats()
|
||||
silver = self.silver_stats()
|
||||
items = self.item_stats()
|
||||
|
||||
def mousePressEvent(self, event):
|
||||
self.mouse_pos = event.pos()
|
||||
self.header.update_status()
|
||||
self.elapsed_card.update_value(self._format_time(elapsed))
|
||||
self.fame_card.update_value(fame_stat.fame)
|
||||
self.fph_card.update_value(fame_stat.fame_per_hour)
|
||||
self.ready_card.update_value('Ready' if engine.is_ready() else 'Not ready')
|
||||
|
||||
def mouseMoveEvent(self, event):
|
||||
invalid_regions = (
|
||||
self.top_bar.geometry(),
|
||||
self.view.geometry(),
|
||||
)
|
||||
self.items_panel.update(items)
|
||||
self._set_page_copy(players, total_healing, silver, items)
|
||||
|
||||
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),
|
||||
}
|
||||
def primary_stats(self):
|
||||
stat_kind = {
|
||||
Page.Overview: engine.CombatStatType.Damage,
|
||||
Page.Damage: engine.CombatStatType.Damage,
|
||||
Page.Healing: engine.CombatStatType.Healing,
|
||||
Page.Economy: engine.CombatStatType.Damage,
|
||||
Page.Items: engine.CombatStatType.Damage,
|
||||
Page.Settings: engine.CombatStatType.Damage,
|
||||
}[self.current_page]
|
||||
getters = {
|
||||
StatsType.ZONE: functools.partial(engine.zone_stats, stat_kind),
|
||||
StatsType.LAST_FIGHT: functools.partial(engine.last_fight_stats, stat_kind),
|
||||
StatsType.OVERALL: functools.partial(engine.overall_stats, stat_kind),
|
||||
}
|
||||
return getters[self.current_scope]()
|
||||
|
||||
return stats[self.top_bar.view_type.get_view_type()][self.view.get_mode()]()
|
||||
def total_healing_stats(self):
|
||||
getters = {
|
||||
StatsType.ZONE: engine.zone_total_healing_stats,
|
||||
StatsType.LAST_FIGHT: engine.last_fight_total_healing_stats,
|
||||
StatsType.OVERALL: engine.overall_total_healing_stats,
|
||||
}
|
||||
return getters[self.current_scope]()
|
||||
|
||||
def silver_stats(self):
|
||||
getters = {
|
||||
StatsType.ZONE: functools.partial(engine.silver_stats_for, engine.VisibilityType.Zone),
|
||||
StatsType.LAST_FIGHT: functools.partial(engine.silver_stats_for, engine.VisibilityType.LastFight),
|
||||
StatsType.OVERALL: functools.partial(engine.silver_stats_for, engine.VisibilityType.Overall),
|
||||
}
|
||||
return getters[self.current_scope]()
|
||||
|
||||
def item_stats(self):
|
||||
getters = {
|
||||
StatsType.ZONE: functools.partial(engine.item_stats_for, engine.VisibilityType.Zone),
|
||||
StatsType.LAST_FIGHT: functools.partial(engine.item_stats_for, engine.VisibilityType.LastFight),
|
||||
StatsType.OVERALL: functools.partial(engine.item_stats_for, engine.VisibilityType.Overall),
|
||||
}
|
||||
return getters[self.current_scope]()
|
||||
|
||||
def _set_page_copy(self, players, total_healing, silver, items):
|
||||
self.primary_list.hide()
|
||||
self.plain_list.hide()
|
||||
self.primary_label.hide()
|
||||
self.total_healing_label.hide()
|
||||
self.total_healing_list.hide()
|
||||
self.placeholder.hide()
|
||||
self.settings_panel.hide()
|
||||
|
||||
if self.current_page == Page.Overview:
|
||||
self.page_title.setText('Overview')
|
||||
self.page_description.setText(
|
||||
'A quick session summary for the selected scope. Use the left menu to inspect damage, healing, economy, and loot in more detail.')
|
||||
self.primary_label.setText('Top Damage Dealers')
|
||||
self.primary_label.show()
|
||||
self.primary_list.show()
|
||||
self.primary_list.update(players)
|
||||
return
|
||||
|
||||
if self.current_page == Page.Damage:
|
||||
self.page_title.setText('Damage Done')
|
||||
self.page_description.setText(
|
||||
'Damage attributed to each visible tracked player during the selected scope. DPS is based on combat time.')
|
||||
self.primary_label.setText('Damage by Player')
|
||||
self.primary_label.show()
|
||||
self.primary_list.show()
|
||||
self.primary_list.update(players)
|
||||
return
|
||||
|
||||
if self.current_page == Page.Healing:
|
||||
self.page_title.setText('Healing Done')
|
||||
self.page_description.setText(
|
||||
'Combat healing counts healing during fights. Total healing includes self-healing and post-fight recovery.')
|
||||
self.primary_label.setText('Combat Healing')
|
||||
self.primary_label.show()
|
||||
self.primary_list.show()
|
||||
self.primary_list.update(players)
|
||||
self.total_healing_label.show()
|
||||
self.total_healing_list.show()
|
||||
self.total_healing_list.update(total_healing)
|
||||
return
|
||||
|
||||
if self.current_page == Page.Economy:
|
||||
self.page_title.setText('Economy')
|
||||
self.page_description.setText(
|
||||
'Silver tracking is active with conservative packet filters. Looted Silver and Other Silver are separated for validation against your next capture.')
|
||||
self.primary_label.setText('Silver Gained')
|
||||
self.primary_label.show()
|
||||
self.plain_list.show()
|
||||
self.plain_list.update(silver)
|
||||
return
|
||||
|
||||
if self.current_page == Page.Items:
|
||||
self.page_title.setText('Items Collected')
|
||||
self.page_description.setText(
|
||||
'Collected item quantities from item pickup packets. The right panel shows selected-scope item totals on every page.')
|
||||
self.primary_label.setText('Items by Quantity')
|
||||
self.primary_label.show()
|
||||
self.plain_list.show()
|
||||
self.plain_list.update(items)
|
||||
return
|
||||
|
||||
self.page_title.setText('Settings')
|
||||
self.page_description.setText('Reset scopes, view app information, and configure dashboard behavior.')
|
||||
self.settings_panel.show()
|
||||
|
||||
def _format_time(self, seconds):
|
||||
seconds = int(seconds or 0)
|
||||
hours = seconds // 3600
|
||||
minutes = (seconds % 3600) // 60
|
||||
remainder = seconds % 60
|
||||
if hours:
|
||||
return f'{hours}h {minutes}m {remainder}s'
|
||||
return f'{minutes}m {remainder}s'
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
|
||||
from PySide2.QtWidgets import QPushButton # type: ignore
|
||||
from PySide2 import QtGui # type: ignore
|
||||
from PySide6.QtWidgets import QPushButton # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
|
||||
from ....utils import assets
|
||||
from ....stats.list_item import PlayerListItem
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
from io import BytesIO
|
||||
from PIL import Image, ImageQt # type: ignore
|
||||
from PySide2 import QtGui # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
|
||||
from .....utils import async_request
|
||||
|
||||
@@ -11,6 +11,9 @@ icon_cache = {}
|
||||
def get_weapon_icon(weapon):
|
||||
global icon_cache
|
||||
|
||||
if not weapon:
|
||||
return None
|
||||
|
||||
url = f'https://albiononline2d.ams3.cdn.digitaloceanspaces.com/thumbnails/orig/{weapon}'
|
||||
|
||||
if weapon in icon_cache:
|
||||
@@ -18,6 +21,8 @@ def get_weapon_icon(weapon):
|
||||
|
||||
try:
|
||||
r = async_request.get(url)
|
||||
if r is None or not r.ok:
|
||||
return None
|
||||
img = Image.open(BytesIO(r.content))
|
||||
|
||||
img_qt = ImageQt.ImageQt(img)
|
||||
|
||||
@@ -3,28 +3,26 @@ 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 PySide6 import QtCore # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
from PySide6.QtCore import Qt # type: ignore
|
||||
from PySide6.QtGui import QStandardItem # type: ignore
|
||||
from PySide6.QtGui import QStandardItemModel # type: ignore
|
||||
from PySide6.QtWidgets import QApplication # type: ignore
|
||||
from PySide6.QtWidgets import QComboBox # type: ignore
|
||||
from PySide6.QtWidgets import QHBoxLayout # type: ignore
|
||||
from PySide6.QtWidgets import QLabel # type: ignore
|
||||
from PySide6.QtWidgets import QListView # type: ignore
|
||||
from PySide6.QtWidgets import QMessageBox # type: ignore
|
||||
from PySide6.QtWidgets import QProgressBar # type: ignore
|
||||
from PySide6.QtWidgets import QPushButton # type: ignore
|
||||
from PySide6.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', 'fg'])
|
||||
|
||||
enchant_re = re.compile(r"(.*)@(\d+)")
|
||||
@@ -114,11 +112,8 @@ class ListItemView(QListView):
|
||||
player_style(self.player.items).fg))
|
||||
self.setForeground(brush_fg)
|
||||
|
||||
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):
|
||||
|
||||
@@ -1,14 +1,16 @@
|
||||
# from PySide2.QtCore import QTimer
|
||||
# from PySide2.QtCore import Qt
|
||||
# from PySide6.QtCore import QTimer
|
||||
# from PySide6.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 PySide6.QtWidgets import QHBoxLayout # type: ignore
|
||||
from PySide6.QtWidgets import QVBoxLayout # type: ignore
|
||||
from PySide6.QtWidgets import QComboBox # type: ignore
|
||||
from PySide6.QtWidgets import QLabel # type: ignore
|
||||
from PySide6.QtWidgets import QWidget # type: ignore
|
||||
|
||||
from ....stats.list_item import PlayerListItem
|
||||
from ..view_type import ViewType
|
||||
|
||||
from .list_view import ListItemView
|
||||
from .stats_type import StatsType
|
||||
@@ -56,20 +58,38 @@ class ModeBasedListView(QWidget):
|
||||
QWidget.__init__(self)
|
||||
self.layout = QVBoxLayout()
|
||||
self.layout.setSpacing(0)
|
||||
self.layout.setMargin(0)
|
||||
self.layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.session_bar = SessionBar(clipboard)
|
||||
self.layout.addWidget(self.session_bar)
|
||||
|
||||
self.list_view = ListItemView()
|
||||
self.layout.addWidget(self.list_view)
|
||||
|
||||
self.total_healing_label = QLabel('Total Healing')
|
||||
self.layout.addWidget(self.total_healing_label)
|
||||
|
||||
self.total_healing_view = ListItemView()
|
||||
self.layout.addWidget(self.total_healing_view)
|
||||
|
||||
self.total_healing_label.hide()
|
||||
self.total_healing_view.hide()
|
||||
|
||||
self.setLayout(self.layout)
|
||||
|
||||
def update(self, prefix, elapsed, fame, fame_per_hour, players: PlayerListItem):
|
||||
def update(self, prefix, elapsed, fame, fame_per_hour,
|
||||
players: PlayerListItem, total_healing: 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)
|
||||
if prefix == ViewType.HEALING_DONE and total_healing:
|
||||
self.total_healing_label.show()
|
||||
self.total_healing_view.show()
|
||||
self.total_healing_view.update(total_healing)
|
||||
else:
|
||||
self.total_healing_label.hide()
|
||||
self.total_healing_view.hide()
|
||||
self.total_healing_view.update([])
|
||||
self.session_bar.update()
|
||||
|
||||
def get_mode(self) -> str:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
import datetime
|
||||
|
||||
from PySide2.QtWidgets import QLabel # type: ignore
|
||||
from PySide2 import QtGui # type: ignore
|
||||
from PySide2 import QtCore # type: ignore
|
||||
from PySide6.QtWidgets import QLabel # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
from PySide6 import QtCore # type: ignore
|
||||
|
||||
from src.utils import assets, number
|
||||
from src.stats.list_item import PlayerListItem
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
|
||||
from typing import Callable
|
||||
|
||||
from PySide2.QtWidgets import QPushButton # type: ignore
|
||||
from PySide2 import QtGui # type: ignore
|
||||
from PySide6.QtWidgets import QPushButton # type: ignore
|
||||
from PySide6 import QtGui # type: ignore
|
||||
|
||||
from ....utils import assets
|
||||
from ....stats.list_item import PlayerListItem
|
||||
|
||||
+113
-16
@@ -6,31 +6,128 @@ font_size = cfg['window']['font-size']
|
||||
style = """
|
||||
QWidget {
|
||||
font-size: %s;
|
||||
background-color: black;
|
||||
color: white;
|
||||
background-color: #0f172a;
|
||||
color: #e5edf8;
|
||||
}
|
||||
|
||||
#Motd, #Motd > * {
|
||||
background-color: none;
|
||||
color: none;
|
||||
font-size: auto;
|
||||
QPushButton {
|
||||
background-color: #182235;
|
||||
border: 1px solid #2a3a54;
|
||||
border-radius: 8px;
|
||||
padding: 10px 12px;
|
||||
text-align: left;
|
||||
color: #e5edf8;
|
||||
}
|
||||
|
||||
QPushButton:hover {
|
||||
background-color: #24324a;
|
||||
}
|
||||
|
||||
QPushButton:checked {
|
||||
background-color: #f5b942;
|
||||
border-color: #f5b942;
|
||||
color: #111827;
|
||||
font-weight: 700;
|
||||
}
|
||||
|
||||
#Sidebar {
|
||||
background-color: #111827;
|
||||
border-right: 1px solid #263449;
|
||||
min-width: 220px;
|
||||
max-width: 220px;
|
||||
}
|
||||
|
||||
#SidebarToggle {
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
#SidebarTitle {
|
||||
color: #f5b942;
|
||||
font-size: 22px;
|
||||
font-weight: 800;
|
||||
padding: 10px 4px 16px 4px;
|
||||
}
|
||||
|
||||
#SidebarSection {
|
||||
color: #93a4bd;
|
||||
font-weight: 700;
|
||||
padding: 18px 4px 4px 4px;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
#HeaderTitle {
|
||||
font-size: 28px;
|
||||
font-weight: 800;
|
||||
color: #ffffff;
|
||||
}
|
||||
|
||||
#HeaderStatus {
|
||||
color: #9fb0c8;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
#StatCard, #ItemsPanel {
|
||||
background-color: #182235;
|
||||
border: 1px solid #293951;
|
||||
border-radius: 14px;
|
||||
}
|
||||
|
||||
#ItemsPanel {
|
||||
min-width: 300px;
|
||||
max-width: 360px;
|
||||
}
|
||||
|
||||
#CardTitle {
|
||||
color: #9fb0c8;
|
||||
font-size: 13px;
|
||||
font-weight: 700;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
#CardValue {
|
||||
color: #ffffff;
|
||||
font-size: 24px;
|
||||
font-weight: 800;
|
||||
}
|
||||
|
||||
#PageTitle {
|
||||
font-size: 24px;
|
||||
font-weight: 800;
|
||||
color: #ffffff;
|
||||
padding-top: 8px;
|
||||
}
|
||||
|
||||
#PageDescription, #MutedText {
|
||||
color: #a9b7ca;
|
||||
line-height: 1.35;
|
||||
}
|
||||
|
||||
#PanelTitle {
|
||||
color: #f5b942;
|
||||
font-size: 18px;
|
||||
font-weight: 800;
|
||||
padding-top: 8px;
|
||||
}
|
||||
|
||||
QListView {
|
||||
min-height: 100px;
|
||||
background-color: #121c2e;
|
||||
border: 1px solid #293951;
|
||||
border-radius: 12px;
|
||||
padding: 8px;
|
||||
min-height: 160px;
|
||||
}
|
||||
|
||||
QListView::item:selected:active {
|
||||
background-color: black;
|
||||
}
|
||||
|
||||
QListView::item:selected {
|
||||
background-color: black;
|
||||
QListView::item {
|
||||
min-height: 36px;
|
||||
border-radius: 6px;
|
||||
margin: 3px;
|
||||
padding: 4px;
|
||||
}
|
||||
|
||||
QListView::item:selected:active,
|
||||
QListView::item:selected,
|
||||
QListView::item:selected:!active {
|
||||
background-color: black;
|
||||
color: white;
|
||||
background-color: #24324a;
|
||||
color: #ffffff;
|
||||
}
|
||||
|
||||
""" % (font_size)
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
import logging
|
||||
import socket
|
||||
import struct
|
||||
import threading
|
||||
from typing import Callable, List, Optional
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
GAME_PORT = 5056
|
||||
|
||||
PROTO_IPV4 = 0x0800
|
||||
PROTO_IPV6 = 0x86DD
|
||||
PROTO_VLAN = 0x8100
|
||||
PROTO_QINQ = 0x88A8
|
||||
IPPROTO_UDP = 17
|
||||
|
||||
ETH_P_ALL = 0x0003
|
||||
|
||||
MAX_FRAME = 65535
|
||||
|
||||
|
||||
def _extract_udp_payload(frame: bytes) -> Optional[bytes]:
|
||||
"""Returns the UDP payload if the ethernet frame carries UDP on port 5056.
|
||||
|
||||
Handles Ethernet, VLAN tags, IPv4 and IPv6 with basic extension handling.
|
||||
"""
|
||||
pos = 0
|
||||
if len(frame) < 14:
|
||||
return None
|
||||
ethertype = struct.unpack(">H", frame[12:14])[0]
|
||||
pos = 14
|
||||
while ethertype in (PROTO_VLAN, PROTO_QINQ):
|
||||
if len(frame) < pos + 4:
|
||||
return None
|
||||
ethertype = struct.unpack(">H", frame[pos + 2:pos + 4])[0]
|
||||
pos += 4
|
||||
if ethertype == PROTO_IPV4:
|
||||
if len(frame) < pos + 20:
|
||||
return None
|
||||
version_ihl = frame[pos]
|
||||
header_len = (version_ihl & 0x0F) * 4
|
||||
protocol = frame[pos + 9]
|
||||
payload = frame[pos + header_len:]
|
||||
elif ethertype == PROTO_IPV6:
|
||||
if len(frame) < pos + 40:
|
||||
return None
|
||||
next_header = frame[pos + 6]
|
||||
header_len = 40
|
||||
while next_header in (0, 43, 44, 60):
|
||||
if len(frame) < pos + header_len + 8:
|
||||
return None
|
||||
hdr_ext_len = (frame[pos + header_len + 1] + 1) * 8
|
||||
if next_header == 44:
|
||||
next_header = frame[pos + header_len]
|
||||
header_len += 8
|
||||
continue
|
||||
next_header = frame[pos + header_len]
|
||||
header_len += hdr_ext_len
|
||||
protocol = next_header
|
||||
payload = frame[pos + header_len:]
|
||||
else:
|
||||
return None
|
||||
if protocol != IPPROTO_UDP:
|
||||
return None
|
||||
if len(payload) < 8:
|
||||
return None
|
||||
src_port, dst_port, length = struct.unpack(">HHH", payload[0:6])
|
||||
if src_port != GAME_PORT and dst_port != GAME_PORT:
|
||||
return None
|
||||
udp_len = length
|
||||
if udp_len < 8 or udp_len > len(payload):
|
||||
return None
|
||||
return bytes(payload[8:udp_len])
|
||||
|
||||
|
||||
class CaptureEngine:
|
||||
"""Listens for Albion Online traffic on all non-loopback interfaces.
|
||||
|
||||
Mirrors the aoaddons packet sniffer: one AF_PACKET socket per interface,
|
||||
forwarding only UDP packets on port 5056 to a shared decode pipeline.
|
||||
"""
|
||||
|
||||
def __init__(self, on_udp: Callable[[bytes], None]):
|
||||
self._on_udp = on_udp
|
||||
self._sockets: List[socket.socket] = []
|
||||
self._threads: List[threading.Thread] = []
|
||||
self._stop = threading.Event()
|
||||
|
||||
@staticmethod
|
||||
def interface_names() -> List[str]:
|
||||
names = []
|
||||
try:
|
||||
for _index, name in socket.if_nameindex():
|
||||
if name and name != 'lo':
|
||||
names.append(name)
|
||||
except OSError:
|
||||
logger.warning("unable to enumerate network interfaces")
|
||||
return names
|
||||
|
||||
def start(self) -> bool:
|
||||
names = self.interface_names()
|
||||
if not names:
|
||||
logger.warning("no network interfaces available for capture")
|
||||
return False
|
||||
for name in names:
|
||||
try:
|
||||
sock = socket.socket(
|
||||
socket.AF_PACKET, socket.SOCK_RAW, socket.htons(ETH_P_ALL))
|
||||
sock.bind((name, ETH_P_ALL))
|
||||
sock.settimeout(1.0)
|
||||
except OSError as e:
|
||||
logger.warning("unable to bind %s: %s", name, e)
|
||||
continue
|
||||
self._sockets.append(sock)
|
||||
thread = threading.Thread(
|
||||
target=self._run_interface, args=(sock, name), daemon=True)
|
||||
thread.start()
|
||||
self._threads.append(thread)
|
||||
logger.info("capturing on interface %s", name)
|
||||
if not self._sockets:
|
||||
logger.error("no interfaces could be captured (permissions?)")
|
||||
return False
|
||||
return True
|
||||
|
||||
def stop(self):
|
||||
self._stop.set()
|
||||
for sock in self._sockets:
|
||||
try:
|
||||
sock.close()
|
||||
except OSError:
|
||||
pass
|
||||
for thread in self._threads:
|
||||
thread.join(timeout=2.0)
|
||||
self._sockets = []
|
||||
self._threads = []
|
||||
|
||||
def _run_interface(self, sock: socket.socket, interface_name: str):
|
||||
logger.debug("capture thread started for %s", interface_name)
|
||||
try:
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
frame = sock.recv(MAX_FRAME)
|
||||
except socket.timeout:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
payload = _extract_udp_payload(frame)
|
||||
if payload is None:
|
||||
continue
|
||||
try:
|
||||
self._on_udp(payload)
|
||||
except Exception:
|
||||
logger.exception("error handling UDP payload")
|
||||
finally:
|
||||
logger.debug("capture thread stopped for %s", interface_name)
|
||||
Executable
+55
@@ -0,0 +1,55 @@
|
||||
#!/bin/sh
|
||||
# Grant the Python interpreter the capabilities required to capture network
|
||||
# traffic, so that Albion Online Stats does not have to run as root.
|
||||
#
|
||||
# Usage: fixlibpcap.sh [path-to-python-interpreter]
|
||||
|
||||
PYTHON="${1:-$(command -v python3)}"
|
||||
|
||||
if [ -z "$PYTHON" ]; then
|
||||
echo "Could not determine the python interpreter path." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -x "$PYTHON" ]; then
|
||||
echo "Python interpreter '$PYTHON' is not executable." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Resolve symlinks (e.g. venv/bin/python -> /usr/bin/python3). setcap has to be
|
||||
# applied to the real binary, not to a symlink.
|
||||
if readlink -f "$PYTHON" >/dev/null 2>&1; then
|
||||
PYTHON="$(readlink -f "$PYTHON")"
|
||||
elif command -v python3 >/dev/null 2>&1; then
|
||||
PYTHON="$(python3 -c 'import os, sys; print(os.path.realpath(sys.executable))' 2>/dev/null || echo "$PYTHON")"
|
||||
fi
|
||||
|
||||
if ! command -v setcap >/dev/null 2>&1; then
|
||||
echo "The 'setcap' tool was not found." >&2
|
||||
echo "Install libcap before retrying:" >&2
|
||||
echo " Debian/Ubuntu: sudo apt install libcap2-bin" >&2
|
||||
echo " Fedora: sudo dnf install libcap" >&2
|
||||
echo " Arch: sudo pacman -S libcap" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Granting packet capture capabilities to: $PYTHON"
|
||||
echo "You may be asked for a password."
|
||||
|
||||
# pkexec shows a graphical authentication dialog, which works even when the app
|
||||
# was not started from a terminal. Fall back to sudo otherwise.
|
||||
if command -v pkexec >/dev/null 2>&1; then
|
||||
pkexec setcap cap_net_raw,cap_net_admin=eip "$PYTHON"
|
||||
status=$?
|
||||
else
|
||||
sudo setcap cap_net_raw,cap_net_admin=eip "$PYTHON"
|
||||
status=$?
|
||||
fi
|
||||
|
||||
if [ "$status" -ne 0 ]; then
|
||||
echo "Failed to set capture capabilities. Try running the app with sudo:" >&2
|
||||
echo " sudo $(command -v aostats 2>/dev/null || echo 'python -m aostats')" >&2
|
||||
exit "$status"
|
||||
fi
|
||||
|
||||
echo "Done. Please restart Albion Online Stats."
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1 @@
|
||||
11898,Keeper Memory - Shameless or Daring
|
||||
File diff suppressed because one or more lines are too long
@@ -30,8 +30,8 @@ class Party:
|
||||
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
|
||||
return CombatState.InCombat if any(
|
||||
player.combat_state == CombatState.InCombat for player in self.get_visible_players()) else CombatState.OutOfCombat
|
||||
|
||||
def time_in_combat(self) -> float:
|
||||
longest = 0.0
|
||||
@@ -50,6 +50,7 @@ class Player(Stats):
|
||||
items: dict = field(default_factory=lambda: {'weapon': None})
|
||||
damage_done: float = 0.0
|
||||
healing_done: float = 0.0
|
||||
total_healing_done: float = 0.0
|
||||
combat_time: CombatTime = field(default_factory=lambda: CombatTime())
|
||||
combat_state: int = CombatState.OutOfCombat
|
||||
active: bool = False
|
||||
@@ -61,7 +62,7 @@ class Player(Stats):
|
||||
return self.active
|
||||
|
||||
def has_stats(self) -> bool:
|
||||
return bool(self.damage_done or self.healing_done)
|
||||
return bool(self.damage_done or self.healing_done or self.total_healing_done)
|
||||
|
||||
@staticmethod
|
||||
def new(self):
|
||||
@@ -75,6 +76,7 @@ class Player(Stats):
|
||||
self.name = other.name
|
||||
self.damage_done += other.damage_done
|
||||
self.healing_done += other.healing_done
|
||||
self.total_healing_done += other.total_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
|
||||
@@ -92,11 +94,13 @@ class Player(Stats):
|
||||
self.activate()
|
||||
|
||||
def register_healing_done(self, value):
|
||||
self.total_healing_done += value
|
||||
self.activate()
|
||||
|
||||
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()
|
||||
@@ -116,6 +120,11 @@ class Player(Stats):
|
||||
return StandalonePlayerListItem(
|
||||
self.name, self.items, self.healing_done, self.hps, self.combat_state)
|
||||
|
||||
def into_total_healing_list_item(self) -> StandalonePlayerListItem:
|
||||
return StandalonePlayerListItem(
|
||||
self.name, self.items, self.total_healing_done, self.total_hps,
|
||||
self.combat_state)
|
||||
|
||||
@property
|
||||
def time_in_combat(self):
|
||||
if self.combat_state == CombatState.InCombat:
|
||||
@@ -140,6 +149,16 @@ class Player(Stats):
|
||||
|
||||
return time_utils.as_milliseconds(self.healing_done / time_in_combat)
|
||||
|
||||
@property
|
||||
def total_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.total_healing_done / time_in_combat)
|
||||
|
||||
|
||||
class CombatStats(CombatEventReceiver, Stats):
|
||||
def __init__(self, visibility, players=None):
|
||||
@@ -190,6 +209,12 @@ class CombatStats(CombatEventReceiver, Stats):
|
||||
for player in self.visible_players()
|
||||
])
|
||||
|
||||
def players_total_healing(self) -> List[PlayerListItem]:
|
||||
return to_player_list_items([player.into_total_healing_list_item()
|
||||
for player in self.visible_players()
|
||||
if player.total_healing_done
|
||||
])
|
||||
|
||||
def party_combat_state(self):
|
||||
return self.party.combat_state()
|
||||
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Dict
|
||||
|
||||
from ..event_receiver import EconomyEventReceiver
|
||||
from .combat_state import CombatState
|
||||
from .list_item import PlayerListItem, StandalonePlayerListItem, to_player_list_items
|
||||
from .statistics import Stats
|
||||
|
||||
|
||||
@dataclass
|
||||
class ItemTotal:
|
||||
item_id: int
|
||||
item_name: str
|
||||
quantity: int = 0
|
||||
|
||||
|
||||
@dataclass
|
||||
class EconomyStats(EconomyEventReceiver, Stats):
|
||||
looted_silver: float = 0.0
|
||||
other_silver: float = 0.0
|
||||
items: Dict[int, ItemTotal] = field(default_factory=dict)
|
||||
|
||||
@classmethod
|
||||
def new(self):
|
||||
return EconomyStats()
|
||||
|
||||
@classmethod
|
||||
def from_other(other):
|
||||
return EconomyStats(
|
||||
looted_silver=other.looted_silver,
|
||||
other_silver=other.other_silver,
|
||||
items={k: ItemTotal(v.item_id, v.item_name, v.quantity)
|
||||
for k, v in other.items.items()},
|
||||
)
|
||||
|
||||
def update(self, other):
|
||||
self.looted_silver += other.looted_silver
|
||||
self.other_silver += other.other_silver
|
||||
for item_id, item in other.items.items():
|
||||
if item_id not in self.items:
|
||||
self.items[item_id] = ItemTotal(item.item_id, item.item_name)
|
||||
self.items[item_id].quantity += item.quantity
|
||||
|
||||
def on_silver_gained(self, value: float, silver_type: str):
|
||||
if silver_type == 'looted':
|
||||
self.looted_silver += value
|
||||
else:
|
||||
self.other_silver += value
|
||||
|
||||
def on_item_collected(self, item_id: int, item_name: str, quantity: int):
|
||||
if item_id not in self.items:
|
||||
self.items[item_id] = ItemTotal(item_id, item_name)
|
||||
self.items[item_id].quantity += quantity
|
||||
|
||||
def stats(self):
|
||||
return {
|
||||
'looted_silver': self.looted_silver,
|
||||
'other_silver': self.other_silver,
|
||||
'total_silver': self.looted_silver + self.other_silver,
|
||||
}
|
||||
|
||||
def item_list(self):
|
||||
standalone = [
|
||||
StandalonePlayerListItem(
|
||||
item.item_name,
|
||||
{'weapon': None},
|
||||
float(item.quantity),
|
||||
0.0,
|
||||
CombatState.OutOfCombat,
|
||||
)
|
||||
for item in self.items.values()
|
||||
if item.quantity > 0
|
||||
]
|
||||
return to_player_list_items(standalone)
|
||||
|
||||
def silver_list(self):
|
||||
values = [
|
||||
('Looted Silver', self.looted_silver),
|
||||
('Other Silver', self.other_silver),
|
||||
]
|
||||
standalone = [
|
||||
StandalonePlayerListItem(
|
||||
name,
|
||||
{'weapon': None},
|
||||
value,
|
||||
0.0,
|
||||
CombatState.OutOfCombat,
|
||||
)
|
||||
for name, value in values
|
||||
if value > 0
|
||||
]
|
||||
return to_player_list_items(standalone)
|
||||
+4
-10
@@ -3,7 +3,6 @@ import functools
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from typing import List
|
||||
import re
|
||||
from src.utils.config import config
|
||||
|
||||
from ..event_receiver import VisibilityEventReceiver
|
||||
@@ -24,13 +23,13 @@ class Visibility(VisibilityEventReceiver):
|
||||
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))
|
||||
visible = set(self.visible_players)
|
||||
visible.add(self.main_player_name)
|
||||
return bool(self.main_player_name and name in visible)
|
||||
|
||||
@property
|
||||
def is_main_player_visible(self) -> bool:
|
||||
return self.main_player_name is not ""
|
||||
return self.main_player_name != ""
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=128)
|
||||
@@ -39,8 +38,3 @@ def _is_visible_by_config():
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=128)
|
||||
def _compile_pattern(pattern: str):
|
||||
return re.compile(pattern)
|
||||
|
||||
@@ -2,6 +2,10 @@ import threading
|
||||
import queue
|
||||
import requests
|
||||
import collections
|
||||
import logging
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
Item = collections.namedtuple('Item', 'key value')
|
||||
@@ -26,7 +30,11 @@ _update_thread.start()
|
||||
|
||||
|
||||
def _async_req(url):
|
||||
req = requests.get(url)
|
||||
try:
|
||||
req = requests.get(url, timeout=5)
|
||||
except requests.RequestException as e:
|
||||
logger.debug("async request failed for %s: %s", url, e)
|
||||
req = None
|
||||
|
||||
_queue.put(Item(key=url, value=req))
|
||||
|
||||
|
||||
+20
-10
@@ -1,15 +1,20 @@
|
||||
import os
|
||||
import platform
|
||||
import sys
|
||||
import toml
|
||||
|
||||
CFG_VERSION = '0.7'
|
||||
from . import platform_utils
|
||||
|
||||
CFG_VERSION = '0.8'
|
||||
|
||||
default = """
|
||||
[window]
|
||||
width = 300
|
||||
height = 220
|
||||
font-size = '10px'
|
||||
width = 1280
|
||||
height = 720
|
||||
font-size = '14px'
|
||||
fullscreen = true
|
||||
|
||||
# When true, the dashboard opens maximized so it can still be moved between
|
||||
# desktops/monitors by the window manager. Set false to use width/height.
|
||||
|
||||
# Note: do not change!
|
||||
# options bellow are here only for testing purposes
|
||||
@@ -33,11 +38,12 @@ _config = None
|
||||
|
||||
def get_config_path():
|
||||
cfg_file_name = 'albion-online-stats.cfg'
|
||||
script_dir = os.path.dirname(_script_path)
|
||||
if platform.system() == 'Windows':
|
||||
return os.path.join(os.getenv('APPDATA', script_dir), cfg_file_name)
|
||||
else:
|
||||
return os.path.join(script_dir, cfg_file_name)
|
||||
|
||||
cfg_dir = platform_utils.config_dir()
|
||||
if not cfg_dir:
|
||||
cfg_dir = os.path.dirname(os.path.abspath(_script_path))
|
||||
|
||||
return os.path.join(cfg_dir, cfg_file_name)
|
||||
|
||||
|
||||
def config():
|
||||
@@ -48,6 +54,10 @@ def config():
|
||||
|
||||
conf_file = get_config_path()
|
||||
|
||||
conf_dir = os.path.dirname(conf_file)
|
||||
if conf_dir:
|
||||
os.makedirs(conf_dir, exist_ok=True)
|
||||
|
||||
try:
|
||||
with open(conf_file, "r") as cfg_file:
|
||||
cfg = toml.load(cfg_file)
|
||||
|
||||
+9
-1
@@ -1,8 +1,16 @@
|
||||
import json
|
||||
import os
|
||||
|
||||
try:
|
||||
from pyaoaddons import localization_mapping
|
||||
except:
|
||||
except Exception:
|
||||
_PATH = os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
|
||||
'static', 'localization_mapping.json')
|
||||
try:
|
||||
with open(_PATH, encoding='utf-8') as _f:
|
||||
localization_mapping = json.load(_f)
|
||||
except (OSError, ValueError):
|
||||
localization_mapping = {}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
import os
|
||||
import platform
|
||||
import socket
|
||||
from typing import Optional
|
||||
|
||||
WINDOWS = 'Windows'
|
||||
LINUX = 'Linux'
|
||||
MACOS = 'Darwin'
|
||||
|
||||
APP_DIR_NAME = 'albion-online-stats'
|
||||
|
||||
# Name of the platform specific script used to repair packet capture
|
||||
# permissions. ``None`` means that no automatic repair is available.
|
||||
_REPAIR_SCRIPTS = {
|
||||
WINDOWS: 'fixnpcap.bat',
|
||||
LINUX: 'fixlibpcap.sh',
|
||||
MACOS: 'fixlibpcap.sh',
|
||||
}
|
||||
|
||||
|
||||
def system() -> str:
|
||||
return platform.system()
|
||||
|
||||
|
||||
def is_windows() -> bool:
|
||||
return system() == WINDOWS
|
||||
|
||||
|
||||
def is_linux() -> bool:
|
||||
return system() == LINUX
|
||||
|
||||
|
||||
def is_macos() -> bool:
|
||||
return system() == MACOS
|
||||
|
||||
|
||||
def repair_script() -> Optional[str]:
|
||||
return _REPAIR_SCRIPTS.get(system())
|
||||
|
||||
|
||||
def capture_permissions_ok() -> bool:
|
||||
"""Return True when the current process may capture network packets.
|
||||
|
||||
The packet capture backend starts background sniffing threads and reports
|
||||
initialization as successful even when it later fails to open a socket, so
|
||||
on Linux this explicitly probes for ``CAP_NET_RAW`` (required to open
|
||||
``AF_PACKET`` raw sockets). On other platforms there is no easy probe, so
|
||||
``True`` is returned.
|
||||
"""
|
||||
if not is_linux():
|
||||
return True
|
||||
|
||||
euid = getattr(os, 'geteuid', lambda: -1)()
|
||||
if euid == 0:
|
||||
return True
|
||||
|
||||
try:
|
||||
sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW)
|
||||
sock.close()
|
||||
return True
|
||||
except (PermissionError, OSError):
|
||||
return False
|
||||
|
||||
|
||||
def config_dir() -> Optional[str]:
|
||||
"""Return the platform specific directory used to store the config.
|
||||
|
||||
Returns ``None`` when no standard per-user directory can be determined.
|
||||
"""
|
||||
if is_windows():
|
||||
base = os.getenv('APPDATA')
|
||||
return os.path.join(base, APP_DIR_NAME) if base else None
|
||||
|
||||
if is_macos():
|
||||
home = os.path.expanduser('~')
|
||||
if not home or home == '~':
|
||||
return None
|
||||
return os.path.join(home, 'Library', 'Application Support', APP_DIR_NAME)
|
||||
|
||||
if is_linux():
|
||||
base = os.getenv('XDG_CONFIG_HOME')
|
||||
if not base:
|
||||
home = os.path.expanduser('~')
|
||||
if not home or home == '~':
|
||||
return None
|
||||
base = os.path.join(home, '.config')
|
||||
return os.path.join(base, APP_DIR_NAME)
|
||||
|
||||
return None
|
||||
+10
-8
@@ -1,12 +1,18 @@
|
||||
import json
|
||||
import os
|
||||
|
||||
try:
|
||||
from pyaoaddons import item_category_mapping
|
||||
except:
|
||||
except Exception:
|
||||
_PATH = os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
|
||||
'static', 'item_category_mapping.json')
|
||||
try:
|
||||
with open(_PATH, encoding='utf-8') as _f:
|
||||
item_category_mapping = json.load(_f)
|
||||
except (OSError, ValueError):
|
||||
item_category_mapping = {}
|
||||
|
||||
from . import assets
|
||||
|
||||
|
||||
class WeaponType:
|
||||
Arcane = 'arcanestaff'
|
||||
@@ -26,12 +32,8 @@ class WeaponType:
|
||||
Sword = 'sword'
|
||||
|
||||
|
||||
def map_weapon(weapon):
|
||||
return item_category_mapping[weapon] if weapon in item_category_mapping else None
|
||||
|
||||
|
||||
def get_weapon_type(items):
|
||||
weapon = map_weapon(items['weapon'])
|
||||
weapon = item_category_mapping.get(items.get('weapon', None), None)
|
||||
|
||||
if weapon == WeaponType.Arcane:
|
||||
return WeaponType.Arcane
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
version = "1.0.4"
|
||||
version = "1.0.5"
|
||||
@@ -0,0 +1,31 @@
|
||||
import requests
|
||||
|
||||
from src.gui.modules.views.list_view import icon
|
||||
from src.utils import async_request
|
||||
|
||||
|
||||
def test_get_weapon_icon_ignores_missing_weapon(monkeypatch):
|
||||
called = []
|
||||
monkeypatch.setattr(icon.async_request, 'get', lambda url: called.append(url))
|
||||
|
||||
assert icon.get_weapon_icon(None) is None
|
||||
assert called == []
|
||||
|
||||
|
||||
def test_async_request_catches_request_errors(monkeypatch):
|
||||
queued = []
|
||||
|
||||
def raise_connection_error(_url, timeout=None):
|
||||
raise requests.ConnectionError('dns failed')
|
||||
|
||||
class FakeQueue:
|
||||
def put(self, item):
|
||||
queued.append(item)
|
||||
|
||||
monkeypatch.setattr(async_request.requests, 'get', raise_connection_error)
|
||||
monkeypatch.setattr(async_request, '_queue', FakeQueue())
|
||||
|
||||
async_request._async_req('https://example.invalid/icon')
|
||||
|
||||
assert queued[0].key == 'https://example.invalid/icon'
|
||||
assert queued[0].value is None
|
||||
@@ -0,0 +1,104 @@
|
||||
import pytest
|
||||
|
||||
from src import backend_proxy
|
||||
from src import engine
|
||||
|
||||
|
||||
def test_native_backend_available_on_linux():
|
||||
import src.utils.platform_utils as pu
|
||||
|
||||
assert backend_proxy.NATIVE_BACKEND_AVAILABLE == pu.is_linux()
|
||||
|
||||
|
||||
def test_initialize_ok_with_native_backend(monkeypatch):
|
||||
monkeypatch.setattr(backend_proxy, 'NATIVE_BACKEND_AVAILABLE', True)
|
||||
|
||||
assert backend_proxy.initialize() == backend_proxy.InitializationResult.Ok
|
||||
|
||||
|
||||
def test_initialize_without_backend_returns_not_installed(monkeypatch):
|
||||
if backend_proxy.BACKEND_AVAILABLE:
|
||||
pytest.skip('pyaoaddons is installed')
|
||||
|
||||
monkeypatch.setattr(backend_proxy, 'NATIVE_BACKEND_AVAILABLE', False)
|
||||
|
||||
assert backend_proxy.initialize() == \
|
||||
backend_proxy.InitializationResult.BackendNotInstalled
|
||||
|
||||
|
||||
def test_subscribe_starts_native_backend(monkeypatch):
|
||||
started = []
|
||||
monkeypatch.setattr(backend_proxy, 'NATIVE_BACKEND_AVAILABLE', True)
|
||||
monkeypatch.setattr(
|
||||
backend_proxy, '_start_native_backend',
|
||||
lambda callback: started.append(callback) or True)
|
||||
|
||||
callback = lambda event: event
|
||||
result = backend_proxy.subscribe(callback)
|
||||
|
||||
assert started == [callback]
|
||||
assert result is True
|
||||
|
||||
|
||||
def test_subscribe_is_noop_without_backend(monkeypatch):
|
||||
if backend_proxy.BACKEND_AVAILABLE:
|
||||
pytest.skip('pyaoaddons is installed')
|
||||
|
||||
monkeypatch.setattr(backend_proxy, 'NATIVE_BACKEND_AVAILABLE', False)
|
||||
|
||||
assert backend_proxy.subscribe(lambda event: event) is False
|
||||
|
||||
|
||||
def test_start_native_backend_uses_pipeline(monkeypatch):
|
||||
import src.net.capture as capture_mod
|
||||
|
||||
monkeypatch.setattr(backend_proxy, '_capture', None)
|
||||
|
||||
created = {}
|
||||
|
||||
class FakeCapture:
|
||||
def __init__(self, on_udp):
|
||||
created['on_udp'] = on_udp
|
||||
|
||||
def start(self):
|
||||
created['started'] = True
|
||||
return True
|
||||
|
||||
monkeypatch.setattr(capture_mod, 'CaptureEngine', FakeCapture)
|
||||
|
||||
events = []
|
||||
assert backend_proxy._start_native_backend(events.append) is True
|
||||
|
||||
assert created['started'] is True
|
||||
assert callable(created['on_udp'])
|
||||
assert backend_proxy._capture is not None
|
||||
backend_proxy._capture = None
|
||||
|
||||
|
||||
def test_start_native_backend_reports_start_failure(monkeypatch):
|
||||
import src.net.capture as capture_mod
|
||||
|
||||
monkeypatch.setattr(backend_proxy, '_capture', None)
|
||||
|
||||
class FakeCapture:
|
||||
def __init__(self, on_udp):
|
||||
self.on_udp = on_udp
|
||||
|
||||
def start(self):
|
||||
return False
|
||||
|
||||
monkeypatch.setattr(capture_mod, 'CaptureEngine', FakeCapture)
|
||||
|
||||
assert backend_proxy._start_native_backend(lambda event: event) is False
|
||||
assert backend_proxy._capture is None
|
||||
|
||||
|
||||
def test_engine_initialize_reports_subscribe_failure(monkeypatch):
|
||||
monkeypatch.setattr(
|
||||
engine.backend_proxy, 'initialize',
|
||||
lambda: backend_proxy.InitializationResult.Ok)
|
||||
monkeypatch.setattr(
|
||||
engine.backend_proxy, 'subscribe',
|
||||
lambda callback: False)
|
||||
|
||||
assert engine.initialize() == backend_proxy.InitializationResult.UnknownFailure
|
||||
@@ -0,0 +1,37 @@
|
||||
from src.stats.combat_stats import CombatStats
|
||||
|
||||
|
||||
class VisibleAll:
|
||||
def test(self, _name):
|
||||
return True
|
||||
|
||||
|
||||
def test_self_healing_counts_while_in_combat():
|
||||
stats = CombatStats(VisibleAll())
|
||||
stats.on_player_appeared(0, 'Healer')
|
||||
stats.on_enter_combat(0)
|
||||
|
||||
stats.on_health_received(0, 0, 100.0)
|
||||
|
||||
combat_healing = stats.players_healing()
|
||||
total_healing = stats.players_total_healing()
|
||||
|
||||
assert combat_healing[0].name == 'Healer'
|
||||
assert combat_healing[0].value == 100.0
|
||||
assert total_healing[0].value == 100.0
|
||||
|
||||
|
||||
def test_total_healing_includes_post_combat_healing():
|
||||
stats = CombatStats(VisibleAll())
|
||||
stats.on_player_appeared(0, 'Healer')
|
||||
stats.on_enter_combat(0)
|
||||
stats.on_health_received(0, 0, 100.0)
|
||||
stats.on_leave_combat(0)
|
||||
|
||||
stats.on_health_received(0, 0, 50.0)
|
||||
|
||||
combat_healing = stats.players_healing()
|
||||
total_healing = stats.players_total_healing()
|
||||
|
||||
assert combat_healing[0].value == 100.0
|
||||
assert total_healing[0].value == 150.0
|
||||
@@ -0,0 +1,58 @@
|
||||
import os
|
||||
|
||||
from src.utils import config
|
||||
from src.utils import platform_utils
|
||||
|
||||
|
||||
def _set_os(monkeypatch, system):
|
||||
monkeypatch.setattr(platform_utils, 'system', lambda: system)
|
||||
|
||||
|
||||
def test_config_path_linux_uses_xdg_config_home(monkeypatch, tmp_path):
|
||||
_set_os(monkeypatch, platform_utils.LINUX)
|
||||
monkeypatch.setenv('XDG_CONFIG_HOME', str(tmp_path))
|
||||
|
||||
assert config.get_config_path() == os.path.join(
|
||||
str(tmp_path), platform_utils.APP_DIR_NAME, 'albion-online-stats.cfg')
|
||||
|
||||
|
||||
def test_config_path_linux_falls_back_to_home(monkeypatch, tmp_path):
|
||||
_set_os(monkeypatch, platform_utils.LINUX)
|
||||
monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
|
||||
monkeypatch.setenv('HOME', str(tmp_path))
|
||||
|
||||
assert config.get_config_path() == os.path.join(
|
||||
str(tmp_path), '.config', platform_utils.APP_DIR_NAME,
|
||||
'albion-online-stats.cfg')
|
||||
|
||||
|
||||
def test_config_path_windows_uses_appdata(monkeypatch, tmp_path):
|
||||
_set_os(monkeypatch, platform_utils.WINDOWS)
|
||||
monkeypatch.setenv('APPDATA', str(tmp_path))
|
||||
|
||||
assert config.get_config_path() == os.path.join(
|
||||
str(tmp_path), platform_utils.APP_DIR_NAME, 'albion-online-stats.cfg')
|
||||
|
||||
|
||||
def test_config_path_falls_back_to_script_dir(monkeypatch):
|
||||
_set_os(monkeypatch, 'SomethingElse')
|
||||
|
||||
assert os.path.basename(config.get_config_path()) == 'albion-online-stats.cfg'
|
||||
|
||||
|
||||
def test_config_creates_missing_directory(monkeypatch, tmp_path):
|
||||
_set_os(monkeypatch, platform_utils.LINUX)
|
||||
monkeypatch.setenv('XDG_CONFIG_HOME', str(tmp_path))
|
||||
monkeypatch.setattr(config, '_config', None)
|
||||
|
||||
expected = os.path.join(
|
||||
str(tmp_path), platform_utils.APP_DIR_NAME, 'albion-online-stats.cfg')
|
||||
|
||||
cfg = config.config()
|
||||
|
||||
assert os.path.isfile(expected)
|
||||
assert cfg['window']['width'] == 1280
|
||||
assert cfg['window']['height'] == 720
|
||||
assert cfg['window']['fullscreen'] is True
|
||||
|
||||
config._config = None
|
||||
@@ -0,0 +1,546 @@
|
||||
import struct
|
||||
|
||||
import pytest
|
||||
|
||||
from src.decode import photon
|
||||
from src.decode import party_memory
|
||||
from src.decode import translate
|
||||
from src.decode.photon import PhotonDecoder, decode_message18
|
||||
from src.decode.translate import into_game_message
|
||||
from src.decode.world import IdCache, World
|
||||
from src.net.capture import _extract_udp_payload
|
||||
from src.utils import platform_utils
|
||||
|
||||
|
||||
# --- Protocol18 value builders -------------------------------------------------
|
||||
|
||||
def p18_short(value):
|
||||
return bytes([photon.P18['Short']]) + struct.pack('<h', value)
|
||||
|
||||
|
||||
def p18_string(value):
|
||||
data = value.encode('utf-8')
|
||||
return bytes([photon.P18['String']]) + bytes([len(data)]) + data
|
||||
|
||||
|
||||
def p18_compressed_int(value):
|
||||
zz = (value << 1) if value >= 0 else ((-value << 1) - 1)
|
||||
out = bytes([photon.P18['CompressedInt']])
|
||||
while True:
|
||||
b = zz & 0x7F
|
||||
zz >>= 7
|
||||
if zz:
|
||||
out += bytes([b | 0x80])
|
||||
else:
|
||||
return out + bytes([b])
|
||||
|
||||
|
||||
def params_table(entries):
|
||||
out = bytes([len(entries)])
|
||||
for key, encoded in entries:
|
||||
out += bytes([key]) + encoded
|
||||
return out
|
||||
|
||||
|
||||
def event_payload(opcode, entries):
|
||||
table = params_table([(252, p18_short(opcode))] + list(entries))
|
||||
return bytes([0xF3, 0x04, 0x01]) + table
|
||||
|
||||
|
||||
def flagged_event_payload(opcode, entries):
|
||||
table = params_table([(252, p18_short(opcode))] + list(entries))
|
||||
return bytes([0xF3, 0x84, 0x01]) + table
|
||||
|
||||
|
||||
def response_payload(opcode, entries):
|
||||
table = params_table([(253, p18_short(opcode))] + list(entries))
|
||||
debug = bytes([photon.P18['Null']])
|
||||
return bytes([0xF3, 0x03, 0x01]) + struct.pack('<h', 0) + debug + table
|
||||
|
||||
|
||||
def enet_packet(command, msg_bytes):
|
||||
length = 12 + len(msg_bytes)
|
||||
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
|
||||
command_header = struct.pack('>BBBB', command, 0, 0, 0)
|
||||
command_header += struct.pack('>I', length) + struct.pack('>I', 0)
|
||||
return header + command_header + msg_bytes
|
||||
|
||||
|
||||
def enet_unreliable_packet(command, msg_bytes):
|
||||
unreliable_seq = struct.pack('>I', 17)
|
||||
length = 12 + len(unreliable_seq) + len(msg_bytes)
|
||||
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
|
||||
command_header = struct.pack('>BBBB', command, 0, 0, 0)
|
||||
command_header += struct.pack('>I', length) + struct.pack('>I', 0)
|
||||
return header + command_header + unreliable_seq + msg_bytes
|
||||
|
||||
|
||||
# --- Protocol18 primitives ------------------------------------------------------
|
||||
|
||||
def test_varint_roundtrip():
|
||||
assert photon.rd_varint(bytes([0x00]), 0) == (0, 1)
|
||||
assert photon.rd_varint(bytes([0x80, 0x01]), 0) == (128, 2)
|
||||
assert photon.rd_varint(bytes([0xAC, 0x02]), 0) == (300, 2)
|
||||
|
||||
|
||||
def test_zigzag():
|
||||
assert photon.zigzag(0) == 0
|
||||
assert photon.zigzag(1) == -1
|
||||
assert photon.zigzag(2) == 1
|
||||
assert photon.zigzag(3) == -2
|
||||
|
||||
|
||||
def test_decode_params_and_compressed_int():
|
||||
table = params_table([(0, p18_compressed_int(280962)),
|
||||
(2, p18_string('bionicKatana')),
|
||||
(3, p18_compressed_int(4))])
|
||||
params, pos = photon.decode_params18(table, 0)
|
||||
assert params[0] == 280962
|
||||
assert params[2] == 'bionicKatana'
|
||||
assert params[3] == 4
|
||||
assert pos == len(table)
|
||||
|
||||
|
||||
def test_decode_message18_event():
|
||||
payload = event_payload(1, [(0, p18_compressed_int(277536))])
|
||||
message, pos = decode_message18(payload, 0)
|
||||
assert message.kind == 'Event'
|
||||
assert message.code == 1
|
||||
assert message.params[252] == 1
|
||||
assert message.params[0] == 277536
|
||||
assert pos == len(payload)
|
||||
|
||||
|
||||
def test_decode_message18_flagged_event():
|
||||
payload = flagged_event_payload(1, [(0, p18_compressed_int(277536))])
|
||||
message, pos = decode_message18(payload, 0)
|
||||
assert message.kind == 'Event'
|
||||
assert message.params[252] == 1
|
||||
assert message.params[0] == 277536
|
||||
assert pos == len(payload)
|
||||
|
||||
|
||||
# --- eNet envelope + fragments --------------------------------------------------
|
||||
|
||||
def test_decode_packet_reliable():
|
||||
decoder = PhotonDecoder()
|
||||
packet = enet_packet(
|
||||
photon.CMD_SEND_RELIABLE, event_payload(90, [(0, p18_short(7))]))
|
||||
messages = decoder.decode_packet(packet)
|
||||
assert len(messages) == 1
|
||||
assert messages[0].params[252] == 90
|
||||
|
||||
|
||||
def test_decode_packet_observed_unreliable_fragment_command():
|
||||
decoder = PhotonDecoder()
|
||||
packet = enet_unreliable_packet(
|
||||
photon.CMD_SEND_UNRELIABLE_FRAGMENT,
|
||||
flagged_event_payload(1, [(0, p18_short(7))]))
|
||||
messages = decoder.decode_packet(packet)
|
||||
assert len(messages) == 1
|
||||
assert messages[0].params[252] == 1
|
||||
assert messages[0].params[0] == 7
|
||||
|
||||
|
||||
def test_fragment_reassembly():
|
||||
decoder = PhotonDecoder()
|
||||
full = event_payload(29, [(0, p18_short(1234))])
|
||||
split = 5
|
||||
parts = [full[i:i + split] for i in range(0, len(full), split)]
|
||||
messages = []
|
||||
for i, part in enumerate(parts):
|
||||
start_seq, count = 5, len(parts)
|
||||
length = 12 + photon.FRAG_HEADER_LEN + len(part)
|
||||
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
|
||||
cmd = struct.pack('>BBBB', photon.CMD_SEND_FRAGMENT, 0, 0, 0)
|
||||
cmd += struct.pack('>I', length) + struct.pack('>I', 0)
|
||||
cmd += struct.pack('>IIIII', start_seq, count, i, len(full), i * split)
|
||||
messages.extend(decoder.decode_packet(header + cmd + part))
|
||||
assert len(messages) == 1
|
||||
assert messages[0].params[252] == 29
|
||||
assert messages[0].params[0] == 1234
|
||||
|
||||
|
||||
# --- translate ------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize('opcode,name', [
|
||||
(1, 'Leave'),
|
||||
(6, 'HealthUpdate'),
|
||||
(29, 'NewCharacter'),
|
||||
(32, 'ItemGained'),
|
||||
(82, 'UpdateFame'),
|
||||
(90, 'CharacterEquipmentChanged'),
|
||||
(91, 'RegenerationHealthChanged'),
|
||||
(153, 'SilverGained'),
|
||||
(166, 'KnockedDown'),
|
||||
(231, 'PartyJoined'),
|
||||
(233, 'PartyPlayerJoined'),
|
||||
(235, 'PartyPlayerLeft'),
|
||||
])
|
||||
def test_event_opcode_translation(opcode, name):
|
||||
message, _ = decode_message18(event_payload(opcode, []), 0)
|
||||
game = into_game_message(message)
|
||||
assert game is not None
|
||||
assert game.name == name
|
||||
|
||||
|
||||
def test_operation_translation():
|
||||
message, _ = decode_message18(response_payload(2, [(0, p18_short(63))]), 0)
|
||||
game = into_game_message(message)
|
||||
assert game is not None
|
||||
assert game.name == 'Join'
|
||||
|
||||
|
||||
def test_unknown_opcode_ignored():
|
||||
message, _ = decode_message18(event_payload(9999, []), 0)
|
||||
assert into_game_message(message) is None
|
||||
|
||||
|
||||
def test_party_roster_without_opcode_translates():
|
||||
message = photon.PhotonMessage('Event', 1, {
|
||||
0: 123,
|
||||
9: ['bionicKatana', 'Sweetpea23042'],
|
||||
}, None, None)
|
||||
|
||||
game = into_game_message(message)
|
||||
|
||||
assert game is not None
|
||||
assert game.name == 'PartyRoster'
|
||||
assert translate.msg_party_roster_names(game) == [
|
||||
'bionicKatana', 'Sweetpea23042']
|
||||
|
||||
|
||||
def test_unlock_response_string_lists_are_not_party_rosters():
|
||||
message = photon.PhotonMessage('Response', 1, {
|
||||
9: ['UNLOCKED_CLAIMABLE', 'UNLOCKED_CLAIMABLE'],
|
||||
}, None, None)
|
||||
assert into_game_message(message) is None
|
||||
|
||||
|
||||
# --- world ----------------------------------------------------------------------
|
||||
|
||||
def game(name, params=None):
|
||||
return translate.GameMessage(name, 0, params or {})
|
||||
|
||||
|
||||
def test_id_cache_reuses_id_for_name():
|
||||
cache = IdCache()
|
||||
cache.save(100, 'Alice')
|
||||
assert cache.get_static_id(100) == 0
|
||||
cache.save(200, 'Alice')
|
||||
assert cache.get_static_id(200) == 0
|
||||
assert cache.get_static_id(100) is None
|
||||
assert cache.get_static_id(300) is None
|
||||
|
||||
|
||||
def test_world_new_character_player_appeared():
|
||||
world = World()
|
||||
events = world.transform(game('NewCharacter', {0: 1234, 1: 'Alice'}))
|
||||
names = [e['name'] for e in events]
|
||||
assert 'PlayerAppeared' in names
|
||||
appeared = next(e for e in events if e['name'] == 'PlayerAppeared')
|
||||
assert appeared['value'] == {'id': 0, 'name': 'Alice'}
|
||||
|
||||
|
||||
def test_world_join_emits_zone_change_and_main_player():
|
||||
world = World()
|
||||
events = world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
assert events[0] == {'name': 'ZoneChange'}
|
||||
assert events[1]['name'] == 'MainPlayerAppeared'
|
||||
assert world.main_player_id == 0
|
||||
|
||||
second = world.transform(game('Join', {0: 77, 2: 'Alice'}))
|
||||
assert {'name': 'ZoneChange'} not in second
|
||||
|
||||
|
||||
def test_world_main_player_leave_emits_zone_change():
|
||||
world = World()
|
||||
world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
events = world.transform(game('Leave', {0: 63}))
|
||||
assert events == [{'name': 'ZoneChange'}]
|
||||
|
||||
|
||||
def test_world_health_update_damage_and_heal():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
|
||||
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
|
||||
|
||||
damage = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: -80.0}))
|
||||
assert damage[0]['name'] == 'DamageDone'
|
||||
assert damage[0]['value']['source'] == 1 # attacker
|
||||
assert damage[0]['value']['target'] == 0 # victim
|
||||
assert damage[0]['value']['value'] == 80.0
|
||||
|
||||
heal = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: 40.0}))
|
||||
assert heal[0]['name'] == 'HealthReceived'
|
||||
assert heal[0]['value']['source'] == 1
|
||||
assert heal[0]['value']['value'] == 40.0
|
||||
|
||||
|
||||
def test_world_health_update_unknown_actor_dropped():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
|
||||
assert world.transform(game('HealthUpdate', {0: 10, 6: 999, 2: -50.0})) == []
|
||||
|
||||
|
||||
def test_world_regeneration_combat_states():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||
enter = world.transform(game('RegenerationHealthChanged', {0: 10}))
|
||||
assert enter[0]['name'] == 'EnterCombat'
|
||||
leave = world.transform(game('RegenerationHealthChanged', {0: 10, 4: 5.0}))
|
||||
assert leave[0]['name'] == 'LeaveCombat'
|
||||
|
||||
|
||||
def test_world_knocked_down_leaves_combat():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||
events = world.transform(game('KnockedDown', {0: 10}))
|
||||
assert events[0]['name'] == 'LeaveCombat'
|
||||
|
||||
|
||||
def test_world_update_fame_uses_gained():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||
events = world.transform(game('UpdateFame', {0: 10, 1: 5000000, 2: 30000}))
|
||||
assert events[0]['name'] == 'UpdateFame'
|
||||
assert events[0]['value']['value'] == pytest.approx(3.0)
|
||||
|
||||
|
||||
def test_world_update_fame_delta_from_total():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||
assert world.transform(game('UpdateFame', {0: 10, 1: 2000000})) == []
|
||||
events = world.transform(game('UpdateFame', {0: 10, 1: 2001000}))
|
||||
assert events[0]['value']['value'] == pytest.approx(0.1)
|
||||
|
||||
|
||||
def test_world_item_gained_emits_collected_item():
|
||||
world = World()
|
||||
world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
events = world.transform(game('ItemGained', {1: 522, 2: 3, 4: 10000000}))
|
||||
assert events == [{
|
||||
'name': 'ItemCollected',
|
||||
'value': {
|
||||
'item_id': 522,
|
||||
'item_name': 'T4_MEAL_SALAD_FISH@3',
|
||||
'quantity': 3,
|
||||
'estimated_value': 10000000,
|
||||
},
|
||||
}]
|
||||
|
||||
|
||||
def test_world_item_gained_waits_for_main_player_join():
|
||||
world = World()
|
||||
assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == []
|
||||
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'SomeoneElse'}))
|
||||
assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == []
|
||||
|
||||
|
||||
def test_world_item_gained_uses_display_name_and_deduplicates():
|
||||
world = World()
|
||||
world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
|
||||
first = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1}))
|
||||
duplicate = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1}))
|
||||
|
||||
assert first == [{
|
||||
'name': 'ItemCollected',
|
||||
'value': {
|
||||
'item_id': 11898,
|
||||
'item_name': 'Keeper Memory - Shameless or Daring',
|
||||
'quantity': 1,
|
||||
},
|
||||
}]
|
||||
assert duplicate == []
|
||||
|
||||
|
||||
def test_world_silver_gained_tracks_known_sources():
|
||||
world = World()
|
||||
world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
looted = world.transform(game('SilverGained', {1: 54, 2: 45}))
|
||||
other = world.transform(game('SilverGained', {1: 168, 2: 45}))
|
||||
ignored = world.transform(game('SilverGained', {1: 126, 2: 81}))
|
||||
|
||||
assert looted == [{'name': 'SilverGained', 'value': {
|
||||
'value': 45.0, 'silver_type': 'looted'}}]
|
||||
assert other == []
|
||||
assert ignored == []
|
||||
|
||||
|
||||
def test_world_silver_gained_waits_for_main_player_join():
|
||||
world = World()
|
||||
assert world.transform(game('SilverGained', {1: 54, 2: 45})) == []
|
||||
|
||||
|
||||
def test_world_unconsumed_equipment_replayed_on_new_character():
|
||||
world = World()
|
||||
# equipment arrives before the player is named -> buffered
|
||||
assert world.transform(
|
||||
game('CharacterEquipmentChanged', {0: 55, 2: [0, 1]})) == []
|
||||
events = world.transform(game('NewCharacter', {0: 55, 1: 'Alice'}))
|
||||
names = [e['name'] for e in events]
|
||||
assert 'PlayerAppeared' in names
|
||||
assert 'UpdateItems' in names
|
||||
|
||||
|
||||
def test_party_events_from_structures():
|
||||
world = World()
|
||||
world.party.set_main_player_name('Alice')
|
||||
world.cache.save(1, 'Alice')
|
||||
joined = world.transform(
|
||||
game('PartyJoined', {4: [[1, 0], [2, 0]], 5: ['Alice', 'Bob']}))
|
||||
assert joined[0]['name'] == 'UpdateParty'
|
||||
assert joined[0]['value']['player_names'] == ['Alice', 'Bob']
|
||||
|
||||
left = world.transform(game('PartyPlayerLeft', {1: [2, 0]}))
|
||||
assert left[0]['value']['player_names'] == ['Alice']
|
||||
|
||||
|
||||
def test_party_roster_event_updates_party():
|
||||
world = World()
|
||||
events = world.transform(game('PartyRoster', {
|
||||
9: ['bionicKatana', 'Sweetpea23042'],
|
||||
}))
|
||||
|
||||
assert events == [{
|
||||
'name': 'UpdateParty',
|
||||
'value': {'player_names': ['bionicKatana', 'Sweetpea23042']},
|
||||
}]
|
||||
|
||||
|
||||
def test_remembered_party_reemits_on_join(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
party_memory.save_last_party([
|
||||
'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade'])
|
||||
|
||||
world = World(remember_last_party=True)
|
||||
events = world.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
|
||||
|
||||
assert events[-1] == {
|
||||
'name': 'UpdateParty',
|
||||
'value': {'player_names': [
|
||||
'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade']},
|
||||
}
|
||||
|
||||
|
||||
def test_party_inference_grows_during_zone_load(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
world = World(remember_last_party=True)
|
||||
|
||||
world.transform(game('NewCharacter', {0: 97, 1: 'rainbowShade'}))
|
||||
join = world.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
|
||||
fatbrick = world.transform(game('NewCharacter', {0: 161, 1: 'fatbrick'}))
|
||||
froedrick = world.transform(game('NewCharacter', {0: 211, 1: 'Froedrick712'}))
|
||||
|
||||
assert _last_party_names(join) == [
|
||||
'rainbowShade', 'bionicKatana']
|
||||
assert _last_party_names(fatbrick) == [
|
||||
'rainbowShade', 'bionicKatana', 'fatbrick']
|
||||
assert _last_party_names(froedrick) == [
|
||||
'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712']
|
||||
assert party_memory.load_last_party() == [
|
||||
'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712']
|
||||
|
||||
|
||||
def test_party_roster_saves_even_when_autoload_disabled(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
world = World(remember_last_party=False)
|
||||
|
||||
world.transform(game('PartyRoster', {
|
||||
9: ['bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712'],
|
||||
}))
|
||||
|
||||
assert party_memory.load_last_party() == [
|
||||
'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712']
|
||||
|
||||
restarted = World(remember_last_party=True)
|
||||
events = restarted.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
|
||||
|
||||
assert events[-1]['value']['player_names'] == [
|
||||
'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712']
|
||||
|
||||
|
||||
def test_party_disband_preserves_remembered_party(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
world = World(remember_last_party=True)
|
||||
|
||||
world.transform(game('PartyRoster', {
|
||||
9: ['bionicKatana', 'fatbrick'],
|
||||
}))
|
||||
assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick']
|
||||
|
||||
world.transform(game('PartyDisbanded'))
|
||||
|
||||
assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick']
|
||||
assert world.party.last_names == []
|
||||
|
||||
|
||||
def _last_party_names(events):
|
||||
party_events = [e for e in events if e['name'] == 'UpdateParty']
|
||||
return party_events[-1]['value']['player_names']
|
||||
|
||||
|
||||
def test_party_main_player_left_disbands():
|
||||
world = World()
|
||||
world.party.set_main_player_name('Alice')
|
||||
world.transform(game('PartyJoined', {4: [[1, 0], [2, 0]],
|
||||
5: ['Alice', 'Bob']}))
|
||||
events = world.transform(game('PartyPlayerLeft', {1: [1, 0]}))
|
||||
assert events[0]['value']['player_names'] == []
|
||||
|
||||
|
||||
# --- capture frame extraction ---------------------------------------------------
|
||||
|
||||
def build_ethernet_ipv4_udp(src_port, dst_port, payload):
|
||||
udp = struct.pack('>HHHH', src_port, dst_port, 8 + len(payload), 0) + payload
|
||||
ip = bytearray(20)
|
||||
ip[0] = 0x45
|
||||
ip[2:4] = struct.pack('>H', 20 + len(udp))
|
||||
ip[9] = 17
|
||||
ip[12:16] = bytes([10, 0, 0, 1])
|
||||
ip[16:20] = bytes([10, 0, 0, 2])
|
||||
ethernet = bytes(12) + struct.pack('>H', 0x0800)
|
||||
return ethernet + bytes(ip) + udp
|
||||
|
||||
|
||||
def test_extract_udp_payload_game_port():
|
||||
frame = build_ethernet_ipv4_udp(12345, 5056, b'hello')
|
||||
assert _extract_udp_payload(frame) == b'hello'
|
||||
|
||||
|
||||
def test_extract_udp_payload_other_port_ignored():
|
||||
frame = build_ethernet_ipv4_udp(12345, 1234, b'hello')
|
||||
assert _extract_udp_payload(frame) is None
|
||||
|
||||
|
||||
def test_extract_udp_payload_with_vlan():
|
||||
inner = build_ethernet_ipv4_udp(5056, 12345, b'world')
|
||||
header = inner[:12]
|
||||
tagged = header + struct.pack('>H', 0x8100) + struct.pack('>H', 42) + inner[12:]
|
||||
assert _extract_udp_payload(tagged) == b'world'
|
||||
|
||||
|
||||
def build_ethernet_ipv6_udp(src_port, dst_port, payload):
|
||||
udp = struct.pack('>HHHH', src_port, dst_port, 8 + len(payload), 0) + payload
|
||||
ip = bytearray(40)
|
||||
ip[0] = 0x60
|
||||
ip[6] = 17
|
||||
ip[8:24] = bytes.fromhex('fe800000000000000000000000000001')
|
||||
ip[24:40] = bytes.fromhex('fe800000000000000000000000000002')
|
||||
ethernet = bytes(12) + struct.pack('>H', 0x86DD)
|
||||
return ethernet + bytes(ip) + udp
|
||||
|
||||
|
||||
def test_extract_udp_payload_ipv6():
|
||||
frame = build_ethernet_ipv6_udp(5056, 12345, b'v6')
|
||||
assert _extract_udp_payload(frame) == b'v6'
|
||||
|
||||
|
||||
def test_interface_names_excludes_loopback():
|
||||
from src.net.capture import CaptureEngine
|
||||
|
||||
names = CaptureEngine.interface_names()
|
||||
assert isinstance(names, list)
|
||||
assert 'lo' not in names
|
||||
@@ -0,0 +1,31 @@
|
||||
import json
|
||||
|
||||
from src import environment
|
||||
from src.decode import discovery
|
||||
|
||||
|
||||
def test_qt_args_removes_app_specific_options():
|
||||
assert environment.qt_args([
|
||||
'aostats', '--verbose', '--log-path', '/tmp/capture.jsonl',
|
||||
'--style', 'fusion']) == ['aostats', '--style', 'fusion']
|
||||
|
||||
assert environment.qt_args([
|
||||
'aostats', '--log-path=/tmp/capture.jsonl']) == ['aostats']
|
||||
|
||||
|
||||
def test_discovery_log_writes_jsonl_with_item_annotations(monkeypatch, tmp_path):
|
||||
path = tmp_path / 'capture.jsonl'
|
||||
monkeypatch.setattr(discovery, 'discovery_log_path', lambda: str(path))
|
||||
monkeypatch.setattr(discovery, '_initialized', False)
|
||||
monkeypatch.setattr(discovery.itemdb, 'get_db', lambda: {836: 'T6_STONEBLOCK'})
|
||||
|
||||
discovery.log('game_message', params={1: [836], 2: b'\x01'})
|
||||
|
||||
rows = [json.loads(line) for line in path.read_text().splitlines()]
|
||||
assert rows[0]['type'] == 'session_start'
|
||||
assert rows[1]['type'] == 'game_message'
|
||||
assert discovery.item_candidates({1: [836]}) == [{
|
||||
'path': '1[0]',
|
||||
'id': 836,
|
||||
'unique_name': 'T6_STONEBLOCK',
|
||||
}]
|
||||
@@ -0,0 +1,29 @@
|
||||
from src.stats.economy_stats import EconomyStats
|
||||
|
||||
|
||||
def test_economy_stats_accumulates_silver_and_items():
|
||||
stats = EconomyStats()
|
||||
stats.receive({'name': 'SilverGained', 'value': {
|
||||
'value': 45.0, 'silver_type': 'looted'}})
|
||||
stats.receive({'name': 'SilverGained', 'value': {
|
||||
'value': 12.0, 'silver_type': 'other'}})
|
||||
stats.receive({'name': 'ItemCollected', 'value': {
|
||||
'item_id': 522,
|
||||
'item_name': 'T4_MEAL_SALAD_FISH@3',
|
||||
'quantity': 3,
|
||||
}})
|
||||
stats.receive({'name': 'ItemCollected', 'value': {
|
||||
'item_id': 522,
|
||||
'item_name': 'T4_MEAL_SALAD_FISH@3',
|
||||
'quantity': 4,
|
||||
}})
|
||||
|
||||
assert stats.stats() == {
|
||||
'looted_silver': 45.0,
|
||||
'other_silver': 12.0,
|
||||
'total_silver': 57.0,
|
||||
}
|
||||
items = stats.item_list()
|
||||
assert len(items) == 1
|
||||
assert items[0].name == 'T4_MEAL_SALAD_FISH@3'
|
||||
assert items[0].value == 7.0
|
||||
@@ -0,0 +1,16 @@
|
||||
import importlib
|
||||
import sys
|
||||
|
||||
import src.environment as environment
|
||||
|
||||
|
||||
def test_remember_last_party_flag_is_removed_from_qt_args(monkeypatch):
|
||||
monkeypatch.setattr(sys, 'argv', ['aostats', '--remember-last-party'])
|
||||
reloaded = importlib.reload(environment)
|
||||
|
||||
assert reloaded.remember_last_party() is True
|
||||
assert reloaded.qt_args(['aostats', '--remember-last-party', '--verbose']) == [
|
||||
'aostats']
|
||||
|
||||
sys.argv = ['aostats']
|
||||
importlib.reload(environment)
|
||||
@@ -0,0 +1,57 @@
|
||||
import os
|
||||
import re
|
||||
from collections import Counter
|
||||
|
||||
import pytest
|
||||
|
||||
from src.decode.pipeline import Pipeline
|
||||
|
||||
LOG_PATH = os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'aoaddons.log')
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
not os.path.exists(LOG_PATH),
|
||||
reason='aoaddons.log capture fixture is not available')
|
||||
|
||||
|
||||
def _raw_payloads():
|
||||
payloads = []
|
||||
pattern = re.compile(r'Raw payload: \[([0-9, ]+)\]')
|
||||
with open(LOG_PATH, encoding='utf-8', errors='replace') as log:
|
||||
for line in log:
|
||||
match = pattern.search(line)
|
||||
if match:
|
||||
payloads.append(
|
||||
bytes(int(part) for part in match.group(1).split(',')))
|
||||
return payloads
|
||||
|
||||
|
||||
def test_offline_capture_produces_expected_events():
|
||||
payloads = _raw_payloads()
|
||||
assert payloads, 'no raw payloads found in aoaddons.log'
|
||||
|
||||
events = []
|
||||
pipeline = Pipeline(events.append)
|
||||
for payload in payloads:
|
||||
pipeline.on_udp(payload)
|
||||
|
||||
counts = Counter(event['name'] for event in events)
|
||||
assert counts['MainPlayerAppeared'] >= 1
|
||||
assert counts['PlayerAppeared'] == 2
|
||||
assert counts['ZoneChange'] == 3
|
||||
assert counts['UpdateItems'] >= 4
|
||||
|
||||
|
||||
def test_offline_capture_main_player_stream_is_consistent():
|
||||
events = []
|
||||
pipeline = Pipeline(events.append)
|
||||
for payload in _raw_payloads():
|
||||
pipeline.on_udp(payload)
|
||||
|
||||
assert any(e['name'] == 'ZoneChange' for e in events)
|
||||
main = next(e for e in events if e['name'] == 'MainPlayerAppeared')
|
||||
assert main['value']['name']
|
||||
|
||||
appeared = [e['value']['id'] for e in events
|
||||
if e['name'] == 'PlayerAppeared']
|
||||
assert appeared == [0, 1]
|
||||
@@ -0,0 +1,27 @@
|
||||
import os
|
||||
|
||||
from src.decode import party_memory
|
||||
from src.utils import platform_utils
|
||||
|
||||
|
||||
def test_party_memory_save_load_and_clear(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
|
||||
party_memory.save_last_party([
|
||||
'bionicKatana', 'fatbrick', 'fatbrick', '', None])
|
||||
|
||||
assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick']
|
||||
assert os.path.isfile(tmp_path / 'last-party.json')
|
||||
|
||||
party_memory.clear_last_party()
|
||||
|
||||
assert party_memory.load_last_party() == []
|
||||
assert not os.path.exists(tmp_path / 'last-party.json')
|
||||
|
||||
|
||||
def test_party_memory_ignores_corrupt_file(monkeypatch, tmp_path):
|
||||
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
|
||||
path = tmp_path / 'last-party.json'
|
||||
path.write_text('{not json')
|
||||
|
||||
assert party_memory.load_last_party() == []
|
||||
@@ -0,0 +1,43 @@
|
||||
from src.utils import platform_utils
|
||||
|
||||
|
||||
def test_capture_permissions_ok_when_root(monkeypatch):
|
||||
monkeypatch.setattr(platform_utils, 'is_linux', lambda: True)
|
||||
monkeypatch.setattr(platform_utils.os, 'geteuid', lambda: 0)
|
||||
assert platform_utils.capture_permissions_ok() is True
|
||||
|
||||
|
||||
def test_capture_permissions_ok_when_socket_opens(monkeypatch):
|
||||
monkeypatch.setattr(platform_utils, 'is_linux', lambda: True)
|
||||
monkeypatch.setattr(platform_utils.os, 'geteuid', lambda: 1000)
|
||||
monkeypatch.setattr(
|
||||
platform_utils.socket,
|
||||
'socket',
|
||||
lambda *a, **k: _StubSocket(raise_error=False),
|
||||
)
|
||||
assert platform_utils.capture_permissions_ok() is True
|
||||
|
||||
|
||||
def test_capture_permissions_ok_when_permission_denied(monkeypatch):
|
||||
monkeypatch.setattr(platform_utils, 'is_linux', lambda: True)
|
||||
monkeypatch.setattr(platform_utils.os, 'geteuid', lambda: 1000)
|
||||
monkeypatch.setattr(
|
||||
platform_utils.socket,
|
||||
'socket',
|
||||
lambda *a, **k: _StubSocket(raise_error=True),
|
||||
)
|
||||
assert platform_utils.capture_permissions_ok() is False
|
||||
|
||||
|
||||
def test_capture_permissions_ok_skips_probe_on_other_platforms(monkeypatch):
|
||||
monkeypatch.setattr(platform_utils, 'is_linux', lambda: False)
|
||||
assert platform_utils.capture_permissions_ok() is True
|
||||
|
||||
|
||||
class _StubSocket:
|
||||
def __init__(self, raise_error=False):
|
||||
self._raise_error = raise_error
|
||||
|
||||
def close(self):
|
||||
if self._raise_error:
|
||||
raise PermissionError('Operation not permitted')
|
||||
@@ -0,0 +1,32 @@
|
||||
from src.stats import visibility as visibility_module
|
||||
from src.stats.visibility import Visibility
|
||||
|
||||
|
||||
def test_visibility_uses_exact_names(monkeypatch):
|
||||
monkeypatch.delenv('TESTING', raising=False)
|
||||
monkeypatch.setattr(visibility_module, 'config', lambda: {'app': {}})
|
||||
visibility_module._is_visible_by_config.cache_clear()
|
||||
|
||||
visibility = Visibility()
|
||||
visibility.on_player_appeared('bionicKatana')
|
||||
visibility.on_visible_players_changed(['Sweetpea23042'])
|
||||
|
||||
assert visibility.test('bionicKatana')
|
||||
assert visibility.test('Sweetpea23042')
|
||||
assert not visibility.test('Sweetpea')
|
||||
assert not visibility.test('bionicKatanaExtra')
|
||||
|
||||
|
||||
def test_visibility_treats_regex_characters_as_plain_names(monkeypatch):
|
||||
monkeypatch.delenv('TESTING', raising=False)
|
||||
monkeypatch.setattr(visibility_module, 'config', lambda: {'app': {}})
|
||||
visibility_module._is_visible_by_config.cache_clear()
|
||||
|
||||
visibility = Visibility()
|
||||
visibility.on_player_appeared('main.player')
|
||||
visibility.on_visible_players_changed(['Arcane+Fire'])
|
||||
|
||||
assert visibility.test('main.player')
|
||||
assert visibility.test('Arcane+Fire')
|
||||
assert not visibility.test('mainXplayer')
|
||||
assert not visibility.test('ArcaneeeFire')
|
||||
Reference in New Issue
Block a user