Compare commits

10 Commits

Author SHA1 Message Date
bionickatana 887667af07 Working on fixing crashing
Build / Build source distribution (push) Failing after 1m31s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
2026-10-10 15:28:56 -06:00
bionickatana 60137a2de4 Working on party stuff, mostly works 2026-10-10 14:07:14 -06:00
bionickatana 85a844208a Updated silver and item collection 2026-10-10 12:10:06 -06:00
bionickatana 59a9fa4098 Made application maximized when opened 2026-10-10 00:39:31 -06:00
bionickatana 6e78b282a6 Made application fullscreen 2026-10-10 00:24:58 -06:00
bionickatana 774f596c09 Fixed healing and started working on item collection tracking 2026-10-10 00:17:53 -06:00
bionickatana 3e0ad62cf2 Base working for damage 2026-10-09 23:10:40 -06:00
Wiktor Mazur 2895be91c4 Updated launcher 2021-11-11 19:33:55 +01:00
Wiktor Mazur c582677329 Version update 2021-10-21 21:41:58 +02:00
Wiktor Mazur ac487adf5a pyside2 -> pyside6 2021-10-09 15:20:26 +02:00
58 changed files with 11541 additions and 257 deletions
+1
View File
@@ -0,0 +1 @@
3.10
+2
View File
@@ -1,2 +1,4 @@
include README.md
include src/assets/*.png
include src/static/*
include src/scripts/*
+80 -6
View File
@@ -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.
[![Discord](https://discordapp.com/api/guilds/639922572368150552/widget.png?style=banner2)](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
+3
View File
@@ -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
View File
@@ -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 "$@"
+17 -5
View File
@@ -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'
+66 -14
View File
@@ -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
pyaoaddons.subscribe(callback)
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):
+6
View File
@@ -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'
+2
View File
@@ -0,0 +1,2 @@
from .photon import PhotonDecoder, PhotonMessage
from .world import World
+110
View File
@@ -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}]')
+66
View File
@@ -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
+68
View File
@@ -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
+380
View File
@@ -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]
+52
View File
@@ -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
+249
View File
@@ -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)
+466
View File
@@ -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
View File
@@ -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
View File
@@ -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()]
+20
View File
@@ -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):
+123 -25
View File
@@ -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,7 +115,11 @@ def run():
if window_config['frameless']:
widget.setWindowFlag(Qt.FramelessWindowHint)
widget.show()
if window_config.get('fullscreen', True):
widget.showMaximized()
else:
widget.resize(WIDTH, HEIGHT)
widget.show()
current_version, latest_version = (
get_current_version(), get_latest_version())
@@ -73,21 +134,58 @@ 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!")
msg.setText(
"On windows make sure that WinPcap is installed in your system.")
msg.setInformativeText("WinPcap can be installed from <a href='{}'>here</a> <br>\
<b>Make sure to install with the \"Install Npcap in WinPcap API-compatible Mode\"<b> option<br><br>\
In case where npcap is installed try to fix npcap and restart the app"
.format('https://nmap.org/npcap/dist/npcap-0.9990.exe'))
msg.setStandardButtons(QMessageBox.Ok)
button = QPushButton("Fix npcap")
button.clicked.connect(fix_npcap)
msg.addButton(button, QMessageBox.NoRole)
if initialization_result == InitializationResult.BackendNotInstalled:
msg.setText(
"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_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()
sys.exit(app.exec_())
+1 -1
View File
@@ -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
View File
@@ -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'
+2 -2
View File
@@ -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
+6 -1
View File
@@ -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)
+14 -19
View File
@@ -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):
+28 -8
View File
@@ -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:
+3 -3
View File
@@ -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
+2 -2
View File
@@ -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
View File
@@ -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)
View File
+155
View File
@@ -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)
+55
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
11898,Keeper Memory - Shameless or Daring
File diff suppressed because one or more lines are too long
+29 -4
View File
@@ -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):
@@ -187,7 +206,13 @@ class CombatStats(CombatEventReceiver, Stats):
def players_healing(self) -> List[PlayerListItem]:
return to_player_list_items([player.into_healing_list_item()
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):
+92
View File
@@ -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
View File
@@ -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)
+9 -1
View File
@@ -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
View File
@@ -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)
+10 -2
View File
@@ -1,9 +1,17 @@
import json
import os
try:
from pyaoaddons import localization_mapping
except:
localization_mapping = {}
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 = {}
from . import assets
+89
View File
@@ -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
+11 -9
View File
@@ -1,11 +1,17 @@
import json
import os
try:
from pyaoaddons import item_category_mapping
except:
item_category_mapping = {}
from . import assets
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 = {}
class WeaponType:
@@ -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
View File
@@ -1 +1 @@
version = "1.0.4"
version = "1.0.5"
+31
View File
@@ -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
+104
View File
@@ -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
+37
View File
@@ -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
+58
View File
@@ -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
+546
View File
@@ -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
+31
View File
@@ -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',
}]
+29
View File
@@ -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
+16
View File
@@ -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)
+57
View File
@@ -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]
+27
View File
@@ -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() == []
+43
View File
@@ -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')
+32
View File
@@ -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')
+1
View File
@@ -17,5 +17,6 @@ commands =
[testenv:ut]
deps =
pytest
toml
commands =
python -m pytest tests