Working on party stuff, mostly works

This commit is contained in:
2026-10-10 14:07:14 -06:00
parent 85a844208a
commit 60137a2de4
10 changed files with 400 additions and 21 deletions
+59
View File
@@ -0,0 +1,59 @@
import json
import os
from typing import List
from ..utils import platform_utils
FILE_NAME = 'last-party.json'
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):
return []
names = data.get('player_names') if isinstance(data, dict) else None
if not isinstance(names, list):
return []
return _clean_names(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)
def clear_last_party():
try:
os.remove(memory_path())
except FileNotFoundError:
pass
except OSError:
pass
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
+27
View File
@@ -51,6 +51,17 @@ def _string(value) -> Optional[str]:
return None 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]: def _as_int_list(value) -> List[int]:
if isinstance(value, bytes): if isinstance(value, bytes):
return list(value) return list(value)
@@ -80,6 +91,9 @@ def into_game_message(message: PhotonMessage) -> Optional[GameMessage]:
if message.kind == 'Event': if message.kind == 'Event':
code = _int(message.params.get(252)) code = _int(message.params.get(252))
if code is None: if code is None:
names = msg_party_roster_names_from_params(message.params)
if names:
return GameMessage('PartyRoster', 0, message.params)
return None return None
name = EVENT_NAMES.get(code) name = EVENT_NAMES.get(code)
if name is None: if name is None:
@@ -220,3 +234,16 @@ def msg_party_structure(msg: GameMessage) -> List[int]:
def msg_party_name(msg: GameMessage) -> str: def msg_party_name(msg: GameMessage) -> str:
v = _string(msg.params.get(2)) v = _string(msg.params.get(2))
return v if v is not None else '' 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)
+110 -6
View File
@@ -1,6 +1,8 @@
from typing import Dict, List, Optional from typing import Dict, List, Optional
from .. import environment
from . import items as itemdb from . import items as itemdb
from . import party_memory
from . import translate from . import translate
from .translate import GameMessage from .translate import GameMessage
@@ -58,13 +60,22 @@ class Party:
def __init__(self): def __init__(self):
self.main_player_name: Optional[str] = None self.main_player_name: Optional[str] = None
self.items: List[dict] = [] # {'name', 'id'} self.items: List[dict] = [] # {'name', 'id'}
self.last_names: List[str] = []
def set_main_player_name(self, name: str): def set_main_player_name(self, name: str):
self.main_player_name = name self.main_player_name = name
def _game_event(self) -> dict: def _game_event(self) -> dict:
self.last_names = _unique_names([item['name'] for item in self.items])
return {'name': 'UpdateParty', 'value': { return {'name': 'UpdateParty', 'value': {
'player_names': [item['name'] for item in self.items]}} '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]: def joined(self, msg: GameMessage) -> Optional[dict]:
structures = translate.msg_party_structures(msg) structures = translate.msg_party_structures(msg)
@@ -76,6 +87,7 @@ class Party:
def disbanded(self) -> Optional[dict]: def disbanded(self) -> Optional[dict]:
self.items = [] self.items = []
self.last_names = []
return self._game_event() return self._game_event()
def player_left(self, msg: GameMessage) -> Optional[dict]: def player_left(self, msg: GameMessage) -> Optional[dict]:
@@ -97,6 +109,14 @@ class Party:
}) })
return self._game_event() 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: class UnconsumedMessages:
"""Buffers messages tagged with a dynamic id whose static id is unknown. """Buffers messages tagged with a dynamic id whose static id is unknown.
@@ -117,7 +137,7 @@ class UnconsumedMessages:
class World: class World:
"""Transforms translated game messages into app events (aoaddons world.rs).""" """Transforms translated game messages into app events (aoaddons world.rs)."""
def __init__(self): def __init__(self, remember_last_party: Optional[bool] = None):
self.cache = IdCache() self.cache = IdCache()
self.party = Party() self.party = Party()
self.unconsumed_messages = UnconsumedMessages() self.unconsumed_messages = UnconsumedMessages()
@@ -125,6 +145,14 @@ class World:
self._main_player_joined = False self._main_player_joined = False
self._fame_totals: Dict[int, int] = {} self._fame_totals: Dict[int, int] = {}
self._seen_item_pickups = set() 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 [])
self._zone_candidate_names: List[str] = []
self._explicit_party_seen = False
self._party_inferred = False
def transform(self, message: GameMessage) -> List[dict]: def transform(self, message: GameMessage) -> List[dict]:
if message.name == 'NewCharacter': if message.name == 'NewCharacter':
@@ -150,18 +178,26 @@ class World:
if message.name == 'CharacterEquipmentChanged': if message.name == 'CharacterEquipmentChanged':
return self._on_character_equipment_changed(message) return self._on_character_equipment_changed(message)
if message.name == 'PartyJoined': if message.name == 'PartyJoined':
return self._party_event(self.party.joined(message)) return self._explicit_party_event(self.party.joined(message))
if message.name == 'PartyDisbanded': if message.name == 'PartyDisbanded':
return self._party_event(self.party.disbanded()) return self._explicit_party_event(self.party.disbanded())
if message.name == 'PartyPlayerJoined': if message.name == 'PartyPlayerJoined':
return self._party_event(self.party.single_player_joined(message)) return self._explicit_party_event(self.party.single_player_joined(message))
if message.name == 'PartyPlayerLeft': if message.name == 'PartyPlayerLeft':
return self._party_event(self.party.player_left(message)) return self._explicit_party_event(self.party.player_left(message))
if message.name == 'PartyRoster':
return self._explicit_party_event(self.party.roster(message))
return [] return []
def _party_event(self, event: Optional[dict]) -> List[dict]: def _party_event(self, event: Optional[dict]) -> List[dict]:
return [event] if event is not None else [] 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]: def _on_new_character(self, msg: GameMessage) -> List[dict]:
name = translate.msg_new_character_name(msg) name = translate.msg_new_character_name(msg)
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_source(msg))
@@ -175,6 +211,7 @@ class World:
'name': 'PlayerAppeared', 'name': 'PlayerAppeared',
'value': {'id': static_id, 'name': name}, '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)) items = itemdb.decode_items(translate.msg_new_character_items(msg))
if items: if items:
result.append({ result.append({
@@ -201,17 +238,23 @@ class World:
result.append({'name': 'ZoneChange'}) result.append({'name': 'ZoneChange'})
self.main_player_id = static_id self.main_player_id = static_id
self._main_player_joined = True 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() self._seen_item_pickups.clear()
result.append({ result.append({
'name': 'MainPlayerAppeared', 'name': 'MainPlayerAppeared',
'value': {'id': static_id, 'name': name}, '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)) result.extend(self._replay(dynamic_id))
return result return result
def _on_change_cluster(self, msg: GameMessage) -> List[dict]: def _on_change_cluster(self, msg: GameMessage) -> List[dict]:
if self.main_player_id is None: if self.main_player_id is None:
return [] return []
self._reset_zone_party_inference()
self._seen_item_pickups.clear() self._seen_item_pickups.clear()
return [{'name': 'ZoneChange'}] return [{'name': 'ZoneChange'}]
@@ -223,6 +266,7 @@ class World:
if self.main_player_id == static_id: if self.main_player_id == static_id:
self.main_player_id = None self.main_player_id = None
self._main_player_joined = False self._main_player_joined = False
self._reset_zone_party_inference()
self._seen_item_pickups.clear() self._seen_item_pickups.clear()
return [{'name': 'ZoneChange'}] return [{'name': 'ZoneChange'}]
return [] return []
@@ -344,6 +388,55 @@ class World:
result.extend(self.transform(msg)) result.extend(self.transform(msg))
return result 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 not self._remember_last_party or event is None:
return
names = event.get('value', {}).get('player_names', [])
self._remembered_party_names = _unique_names(names)
if self._remembered_party_names:
party_memory.save_last_party(self._remembered_party_names)
else:
party_memory.clear_last_party()
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: def _dyn(value) -> int:
return int(value) & 0xFFFFFFFF return int(value) & 0xFFFFFFFF
@@ -351,3 +444,14 @@ def _dyn(value) -> int:
def _party_id(party_structure: List[int]) -> int: def _party_id(party_structure: List[int]) -> int:
return sum(party_structure) 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
+11
View File
@@ -28,6 +28,11 @@ DISCOVERY_LOG_PATH = (
_arg_value('--log-path') _arg_value('--log-path')
) )
REMEMBER_LAST_PARTY = bool(
os.getenv('AOSTATS_REMEMBER_LAST_PARTY') or
'--remember-last-party' in sys.argv
)
def is_verbose(): def is_verbose():
return VERBOSE return VERBOSE
@@ -37,6 +42,10 @@ def discovery_log_path():
return DISCOVERY_LOG_PATH return DISCOVERY_LOG_PATH
def remember_last_party():
return REMEMBER_LAST_PARTY
def qt_args(argv: List[str]) -> List[str]: def qt_args(argv: List[str]) -> List[str]:
"""Return argv with app-specific options removed before Qt sees them.""" """Return argv with app-specific options removed before Qt sees them."""
result = [] result = []
@@ -52,6 +61,8 @@ def qt_args(argv: List[str]) -> List[str]:
continue continue
if arg.startswith('--log-path='): if arg.startswith('--log-path='):
continue continue
if arg == '--remember-last-party':
continue
result.append(arg) result.append(arg)
return result return result
+26 -5
View File
@@ -9,6 +9,7 @@ from PySide6.QtWidgets import QFrame # type: ignore
from PySide6.QtWidgets import QGridLayout # type: ignore from PySide6.QtWidgets import QGridLayout # type: ignore
from PySide6.QtWidgets import QHBoxLayout # type: ignore from PySide6.QtWidgets import QHBoxLayout # type: ignore
from PySide6.QtWidgets import QLabel # 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 QPushButton # type: ignore
from PySide6.QtWidgets import QScrollArea # type: ignore from PySide6.QtWidgets import QScrollArea # type: ignore
from PySide6.QtWidgets import QVBoxLayout # type: ignore from PySide6.QtWidgets import QVBoxLayout # type: ignore
@@ -171,7 +172,7 @@ class ItemsPanel(QFrame):
title = QLabel('Items Collected') title = QLabel('Items Collected')
title.setObjectName('PanelTitle') title.setObjectName('PanelTitle')
self.layout.addWidget(title) self.layout.addWidget(title)
self.list = ListItemView() self.list = PlainStatsListView()
self.layout.addWidget(self.list, 1) self.layout.addWidget(self.list, 1)
self.layout.addStretch(1) self.layout.addStretch(1)
self.setLayout(self.layout) self.setLayout(self.layout)
@@ -180,6 +181,22 @@ class ItemsPanel(QFrame):
self.list.update(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): class SettingsPanel(QWidget):
def __init__(self, clipboard): def __init__(self, clipboard):
QWidget.__init__(self) QWidget.__init__(self)
@@ -272,6 +289,9 @@ class MainWidget(QWidget):
self.primary_list = ListItemView() self.primary_list = ListItemView()
self.main_layout.addWidget(self.primary_list, 1) 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 = QLabel('Total Healing')
self.total_healing_label.setObjectName('PanelTitle') self.total_healing_label.setObjectName('PanelTitle')
self.total_healing_list = ListItemView() self.total_healing_list = ListItemView()
@@ -361,6 +381,7 @@ class MainWidget(QWidget):
def _set_page_copy(self, players, total_healing, silver, items): def _set_page_copy(self, players, total_healing, silver, items):
self.primary_list.hide() self.primary_list.hide()
self.plain_list.hide()
self.primary_label.hide() self.primary_label.hide()
self.total_healing_label.hide() self.total_healing_label.hide()
self.total_healing_list.hide() self.total_healing_list.hide()
@@ -406,8 +427,8 @@ class MainWidget(QWidget):
'Silver tracking is active with conservative packet filters. Looted Silver and Other Silver are separated for validation against your next capture.') '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.setText('Silver Gained')
self.primary_label.show() self.primary_label.show()
self.primary_list.show() self.plain_list.show()
self.primary_list.update(silver) self.plain_list.update(silver)
return return
if self.current_page == Page.Items: if self.current_page == Page.Items:
@@ -416,8 +437,8 @@ class MainWidget(QWidget):
'Collected item quantities from item pickup packets. The right panel shows selected-scope item totals on every page.') '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.setText('Items by Quantity')
self.primary_label.show() self.primary_label.show()
self.primary_list.show() self.plain_list.show()
self.primary_list.update(items) self.plain_list.update(items)
return return
self.page_title.setText('Settings') self.page_title.setText('Settings')
+4 -10
View File
@@ -3,7 +3,6 @@ import functools
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import List from typing import List
import re
from src.utils.config import config from src.utils.config import config
from ..event_receiver import VisibilityEventReceiver from ..event_receiver import VisibilityEventReceiver
@@ -24,13 +23,13 @@ class Visibility(VisibilityEventReceiver):
if _is_visible_by_config(): # Note: only for testing purposes if _is_visible_by_config(): # Note: only for testing purposes
return True return True
pattern = '|'.join(self.visible_players) + '|{}'.format( visible = set(self.visible_players)
self.main_player_name) if self.visible_players else self.main_player_name visible.add(self.main_player_name)
return self.main_player_name and bool(_compile_pattern(pattern).match(name)) return bool(self.main_player_name and name in visible)
@property @property
def is_main_player_visible(self) -> bool: def is_main_player_visible(self) -> bool:
return self.main_player_name is not "" return self.main_player_name != ""
@functools.lru_cache(maxsize=128) @functools.lru_cache(maxsize=128)
@@ -39,8 +38,3 @@ def _is_visible_by_config():
return True return True
return False return False
@functools.lru_cache(maxsize=128)
def _compile_pattern(pattern: str):
return re.compile(pattern)
+88
View File
@@ -3,11 +3,13 @@ import struct
import pytest import pytest
from src.decode import photon from src.decode import photon
from src.decode import party_memory
from src.decode import translate from src.decode import translate
from src.decode.photon import PhotonDecoder, decode_message18 from src.decode.photon import PhotonDecoder, decode_message18
from src.decode.translate import into_game_message from src.decode.translate import into_game_message
from src.decode.world import IdCache, World from src.decode.world import IdCache, World
from src.net.capture import _extract_udp_payload from src.net.capture import _extract_udp_payload
from src.utils import platform_utils
# --- Protocol18 value builders ------------------------------------------------- # --- Protocol18 value builders -------------------------------------------------
@@ -194,6 +196,27 @@ def test_unknown_opcode_ignored():
assert into_game_message(message) is None 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 ---------------------------------------------------------------------- # --- world ----------------------------------------------------------------------
def game(name, params=None): def game(name, params=None):
@@ -375,6 +398,71 @@ def test_party_events_from_structures():
assert left[0]['value']['player_names'] == ['Alice'] 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_disband_clears_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() == []
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(): def test_party_main_player_left_disbands():
world = World() world = World()
world.party.set_main_player_name('Alice') world.party.set_main_player_name('Alice')
+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)
+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() == []
+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')