Files
myrzx_bot/ranch_assistant/activity_gui.py
T

377 lines
22 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Native Qt pages for stage selection and daily rewards."""
from PySide6 import QtCore as C, QtWidgets as W
from .daily import DailyPolicy, entries
from .native_widgets import ComboBox, IntegerInput, RowBatch
from .resource_stages import available_item_count, item_requirements
from .sweeping import SweepPolicy
from .table_widgets import SORT_ROLE, TreeItem, bind_controls, set_value, table_item
def number(value, maximum=9999):
widget = IntegerInput()
widget.setRange(0, maximum)
widget.setValue(value)
return widget
class ActivityPages:
def resource_catalog(self):
return self.engine.stage_cache.catalog
def resource_cost_text(self, snapshot, stage):
base = self.resource_catalog().data.get("stage_info", {}).get(stage.stage_id, {}).get("cost") or {}
owned_ti = int(snapshot.raw.get("master", {}).get("ti") or 0)
parts = [f"体力 单次 {stage.stamina} / 可用 {owned_ti} / 保留 {self.map_keep_ti.value()}"]
reserve = self.map_keep_tickets.value()
for key, count in item_requirements(base.get("items") or []).items():
name = self.resource_catalog().data.get("item_names", {}).get(key, key)
owned = available_item_count(snapshot, key)
parts.append(f"{name} 单次 {count} / 可用 {owned} / 保留 {reserve}")
return "\n".join(parts)
def resource_status_text(self, snapshot, stage, policy, reason):
if not stage.battle_available:
return "该资源关卡缺少已提取的战斗配置,未启用"
if not policy.allow_special:
return "尚未开启“允许矿洞 / 门票关卡”资源关开关"
base = self.resource_catalog().data.get("stage_info", {}).get(stage.stage_id, {}).get("cost") or {}
owned_ti = int(snapshot.raw.get("master", {}).get("ti") or 0)
if stage.stamina + self.map_keep_ti.value() > owned_ti:
return f"体力不足:单次需 {stage.stamina},可用 {owned_ti},保留 {self.map_keep_ti.value()}"
reserve = self.map_keep_tickets.value()
for key, count in item_requirements(base.get("items") or []).items():
owned = available_item_count(snapshot, key)
if owned - count < reserve:
name = self.resource_catalog().data.get("item_names", {}).get(key, key)
return f"{name}不足:单次需 {count},可用 {owned},保留 {reserve}"
if reason:
return reason
return "将按实际模拟结果挑战;不是扫荡"
def maps_tab(self):
self.map_rules = {}
self.map_page = W.QWidget()
layout = W.QVBoxLayout(self.map_page)
line = W.QHBoxLayout()
self.map_search = W.QLineEdit()
self.map_search.setPlaceholderText("搜索关卡编号、名称或掉落物品")
self.only_unlocked = W.QCheckBox("只看账号已解锁")
self.only_unlocked.setChecked(True)
self.map_category = ComboBox()
self.map_category.addItem("全部关卡", "all")
self.map_category.addItem("普通关卡", "ordinary")
self.map_category.addItem("矿洞与门票", "resource")
for widget in (self.map_search, self.map_category, self.only_unlocked):
line.addWidget(widget)
for label, function in (("刷新关卡", self.refresh_maps), ("展开地区", lambda: self.maps_tree.expandAll()),
("折叠地区", lambda: self.maps_tree.collapseAll())):
button = W.QPushButton(label)
button.clicked.connect(function)
line.addWidget(button)
layout.addLayout(line)
line = W.QHBoxLayout()
self.map_enabled = W.QCheckBox("启用勾选关卡自动刷图")
self.map_allow_challenge = W.QCheckBox("未满星时自动挑战")
self.map_allow_challenge.setChecked(True)
self.map_keep_ti = number(0)
self.map_team = ComboBox()
for name in ("teamA", "teamB", "teamC"):
self.map_team.addItem(name, name)
line.addWidget(self.map_enabled)
line.addWidget(self.map_allow_challenge)
line.addWidget(W.QLabel("保留体力"))
line.addWidget(self.map_keep_ti)
line.addWidget(W.QLabel("使用战队"))
line.addWidget(self.map_team)
reset = W.QPushButton("处理未完成记录…")
reset.clicked.connect(self.clear_sweep_pending)
line.addWidget(reset)
line.addStretch()
layout.addLayout(line)
line = W.QHBoxLayout()
self.map_allow_special = W.QCheckBox("允许矿洞 / 门票关卡")
self.map_allow_special.setToolTip("仅处理下方单独勾选且已检查支持的资源关卡;不会自动处理所有特殊关卡。")
self.map_keep_tickets = number(0)
self.map_keep_tickets.setToolTip("每种入场门票或工具分别保留此数量;0 表示不额外保留。")
line.addWidget(self.map_allow_special)
line.addWidget(W.QLabel("每种门票/工具保留"))
line.addWidget(self.map_keep_tickets)
line.addStretch()
layout.addLayout(line)
self.maps_summary = W.QLabel("登录后读取实际解锁状态")
self.maps_summary.setWordWrap(True)
layout.addWidget(self.maps_summary)
self.maps_tree = W.QTreeWidget()
self.maps_tree.setHeaderLabels(["刷图", "关卡", "名称", "难度", "星级", "扫荡 / 挑战状态", "体力 / 门票:单次 / 可用 / 保留", "可能掉落", "本日上限", "本日已开始"])
self.maps_tree.setAlternatingRowColors(True)
self.maps_tree.setTextElideMode(C.Qt.TextElideMode.ElideNone)
self.maps_tree.setUniformRowHeights(False)
self.maps_tree.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.maps_tree.itemChanged.connect(self.map_item_changed)
self.maps_tree.sortByColumn(1, C.Qt.SortOrder.AscendingOrder)
self.maps_tree.setSortingEnabled(True)
for col, width in enumerate((100, 82, 160, 130, 70, 270, 300, 340, 100, 92)):
self.maps_tree.setColumnWidth(col, width)
layout.addWidget(self.maps_tree, 1)
note = W.QLabel("地图按账号保存在本地,点击“刷新关卡”可更新完整列表;挑战结束后同步实际进度。星级来自实际通关难度,不能手动修改。\n普通关卡三个难度全部通关后可扫荡;开启“未满星时自动挑战”后,其余已解锁且开放的勾选普通关卡使用内置模拟挑战,共用所选战队、保留体力和本日上限。实际战败显示“打不过”,未支持的内容显示具体原因;未解锁和当前任务拦截的关卡不可刷图。\n矿洞 / 门票关卡需同时开启资源关开关并逐关勾选,仅显示原入口难度1;体力、每种工具的需求与可用库存随账号快照更新。此类关卡按实际模拟结果挑战,不是扫荡,能力检查不通过时不会入场;其他特殊关仍不可刷图。随机掉落并非必得。")
note.setWordWrap(True)
layout.addWidget(note)
self.tabs.addTab(self.map_page, "自动扫荡")
self.map_search.textChanged.connect(self.render_maps)
self.map_category.currentIndexChanged.connect(self.render_maps)
self.only_unlocked.toggled.connect(self.render_maps)
self.map_enabled.toggled.connect(self.activity_settings_changed)
self.map_allow_challenge.toggled.connect(self.activity_settings_changed)
self.map_keep_ti.valueChanged.connect(self.activity_settings_changed)
self.map_allow_special.toggled.connect(self.activity_settings_changed)
self.map_keep_tickets.valueChanged.connect(self.activity_settings_changed)
self.map_team.currentIndexChanged.connect(self.activity_settings_changed)
def read_sweep_policy(self):
import copy
return SweepPolicy(self.map_enabled.isChecked(), copy.deepcopy(self.map_rules), self.map_keep_ti.value(),
self.map_team.currentData(), allow_challenge=self.map_allow_challenge.isChecked(),
allow_special=self.map_allow_special.isChecked(), keep_tickets=self.map_keep_tickets.value())
def reset_map_view(self):
if hasattr(self, "map_render_timer"):
self.map_render_timer.stop()
self.maps_tree.clear()
self._map_items, self._map_cities = {}, {}
def refresh_maps(self):
if self.closed:
return
if self.busy:
self.pending_refresh = self.map_page
self.statusBar().showMessage("当前请求完成后刷新关卡")
return
self.submit("map_refresh", self.engine.refresh_stages)
def activity_settings_changed(self, *args):
if self.closed or self.loading_config:
return
# Stop takes effect immediately, even if the current request is in flight.
if hasattr(self, "map_enabled") and not self.map_enabled.isChecked():
self.engine.sweep_policy.enabled = False
sender = self.sender()
if sender in (self.map_enabled, self.map_allow_challenge, self.map_allow_special) and not sender.isChecked():
field = "enabled" if sender is self.map_enabled else "allow_challenge" if sender is self.map_allow_challenge else "allow_special"
setattr(self.engine.sweep_policy, field, False)
if self.pending_policy is not None:
setattr(self.pending_policy["sweep_policy"], field, False)
pending = self.engine.battle_journal.pending(self.engine.snapshot) if self.engine.snapshot is not None else None
if pending and pending.get("kind") == "map_battle":
self.cancel_progression()
if hasattr(self, "daily_enabled") and not self.daily_enabled.isChecked():
self.engine.daily_policy.enabled = False
self.settings_changed()
if sender in (self.map_allow_challenge, self.map_allow_special, self.map_keep_ti, self.map_keep_tickets):
self.render_maps()
def map_item_changed(self, item, column):
key = item.data(0, C.Qt.ItemDataRole.UserRole)
if key and column == 0:
enabled = item.checkState(0) == C.Qt.CheckState.Checked
if self.map_rules.get(key, {}).get("enabled", False) != enabled:
self.map_rule_changed(key, enabled=enabled)
item.setData(0, SORT_ROLE, int(enabled))
def map_rule_changed(self, key, **changes):
self.map_rules[key] = {"enabled": False, "level": "3", "limit": 3} | self.map_rules.get(key, {}) | changes
self.activity_settings_changed()
if "level" in changes:
C.QTimer.singleShot(0, self.render_maps)
def render_maps(self, *args):
if not hasattr(self, "maps_tree") or self.engine.snapshot is None:
return
focused = W.QApplication.focusWidget()
if isinstance(focused, W.QLineEdit) and self.maps_tree.isAncestorOf(focused):
return
snapshot = self.engine.snapshot
all_rows = self.engine.stage_cache.get(snapshot)
grouped = {}
for row in all_rows:
if row.category in ("mine", "ticket") and row.level != "1":
continue
grouped.setdefault(row.stage_id, []).append(row)
query = self.map_search.text().strip().casefold()
policy = self.read_sweep_policy()
team_ids = self.engine.sweeper.team_ids(snapshot, policy)
visible = []
for key, options in sorted(grouped.items(), key=lambda pair: (pair[1][0].city, pair[1][0].number, pair[0])):
first = options[0]
resource = first.category in ("mine", "ticket")
if ((self.map_category.currentData() == "ordinary" and first.category != "ordinary")
or (self.map_category.currentData() == "resource" and not resource)):
continue
if self.only_unlocked.isChecked() and not any(s.unlocked for s in options):
continue
if query and query not in (first.city_name + key + first.number + first.name + " ".join(s.drops for s in options)).casefold():
continue
rule = self.map_rules.get(key, {})
chosen = next((s for s in options if s.level == str(rule.get("level"))), None) if rule else None
chosen = chosen or next((s for s in reversed(options) if s.unlocked), first)
self.map_rules.setdefault(key, {"enabled": False, "level": chosen.level, "limit": 3})
reason = self.engine.map_stage_reason(snapshot, chosen, policy, team_ids=team_ids)
if resource and rule.get("enabled") and not policy.allow_special:
reason = "尚未开启“允许矿洞 / 门票关卡”资源关开关"
if resource:
reason = self.resource_status_text(snapshot, chosen, policy, reason)
cost_text = self.resource_cost_text(snapshot, chosen) if resource else str(chosen.stamina) + (" / " + chosen.tickets if chosen.tickets else "")
visible.append((key, options, chosen, dict(self.map_rules[key]), reason, cost_text))
self._map_items = getattr(self, "_map_items", {})
self._map_cities = getattr(self, "_map_cities", {})
if not hasattr(self, "map_render_timer"):
self.map_render_timer = RowBatch(self)
wanted = {row[0] for row in visible}
operations = [("remove", key) for key in self._map_items if key not in wanted] + [("row", row) for row in visible]
self.maps_tree.setSortingEnabled(False)
def apply(operation):
kind, data = operation
blocker = C.QSignalBlocker(self.maps_tree)
if kind == "remove":
item = self._map_items.pop(data)
item.parent().takeChild(item.parent().indexOfChild(item))
return
key, options, chosen, rule, reason, cost_text = data
first = options[0]
if first.category in ("mine", "ticket"):
reason = self.resource_status_text(snapshot, chosen, self.read_sweep_policy(), reason)
cost_text = self.resource_cost_text(snapshot, chosen)
city = self._map_cities.get(first.city)
if city is None:
city = TreeItem(self.maps_tree, [first.city_name])
city.setFirstColumnSpanned(True)
city.setExpanded(bool(query))
self._map_cities[first.city] = city
elif query:
city.setExpanded(True)
item = self._map_items.get(key)
if item is None:
item = TreeItem(city)
item.setData(0, C.Qt.ItemDataRole.UserRole, key)
difficulty = ComboBox()
difficulty.currentIndexChanged.connect(lambda index, key=key, widget=difficulty: self.map_rule_changed(key, level=widget.currentData()))
limit = number(rule.get("limit", 3), 999)
limit.valueChanged.connect(lambda value, key=key: self.map_rule_changed(key, limit=value))
self.maps_tree.setItemWidget(item, 3, difficulty)
self.maps_tree.setItemWidget(item, 8, limit)
item.setSizeHint(0, C.QSize(90, max(difficulty.sizeHint().height(), limit.sizeHint().height()) + 4))
self._map_items[key] = item
values = ["", first.number, first.name, "", "★" * first.stars + "☆" * (3 - first.stars), reason or ("可扫荡" if chosen.sweep else "将模拟挑战"),
cost_text, chosen.drops, "", str(self.engine.sweeper.used(snapshot, chosen))]
for col, text in enumerate(values):
if item.text(col) != text:
set_value(item, col, text)
if col in (5, 6, 7):
item.setToolTip(col, text)
item.setCheckState(0, C.Qt.CheckState.Checked if rule.get("enabled") else C.Qt.CheckState.Unchecked)
item.setData(0, SORT_ROLE, int(bool(rule.get("enabled"))))
flags = item.flags()
item.setFlags(flags | C.Qt.ItemFlag.ItemIsUserCheckable if any(s.unlocked and s.open for s in options) else flags & ~C.Qt.ItemFlag.ItemIsUserCheckable)
difficulty = self.maps_tree.itemWidget(item, 3)
block_combo = C.QSignalBlocker(difficulty)
labels = [(f"难度 {s.level}" + ("(已通关)" if s.passed else ""), s.level) for s in options]
if [(difficulty.itemText(i), difficulty.itemData(i)) for i in range(difficulty.count())] != labels:
difficulty.clear()
for text, value in labels:
difficulty.addItem(text, value)
for i, stage in enumerate(options):
difficulty.model().item(i).setEnabled(stage.unlocked and stage.open)
difficulty.setCurrentIndex(difficulty.findData(chosen.level))
self.maps_tree.setColumnWidth(3, max(self.maps_tree.columnWidth(3), difficulty.minimumSizeHint().width()))
limit = self.maps_tree.itemWidget(item, 8)
block_limit = C.QSignalBlocker(limit)
if not limit.hasFocus():
limit.setValue(rule.get("limit", 3))
bind_controls(self.maps_tree, item, {3: difficulty, 8: limit})
def finish():
for cid, city in list(self._map_cities.items()):
if not city.childCount():
self.maps_tree.takeTopLevelItem(self.maps_tree.indexOfTopLevelItem(city))
del self._map_cities[cid]
self.maps_tree.setSortingEnabled(True)
self.map_render_timer.start(operations, apply, finish)
pending = self.engine.sweeper.state.get("pending")
self.maps_summary.setText(f"已解锁 {sum(s.unlocked for s in all_rows)} 个难度;显示 {len(visible)} 关;勾选 {sum(bool(r.get('enabled')) for r in self.map_rules.values())} 关。" +
(f" 待处理:{pending['stage']} / {pending['phase']}" if pending else "") +
(" 刷图策略运行中。" if self.map_enabled.isChecked() and self.strategy_toggle.isChecked() else " 开启顶部策略开关后运行已勾选关卡。"))
def clear_sweep_pending(self):
if self.busy:
self.report("请等待当前请求完成")
return
pending = self.engine.sweeper.state.get("pending")
if not pending:
battle = self.engine.battle_journal.pending(self.engine.snapshot) if self.engine.snapshot is not None else None
if battle and battle.get("kind") == "map_battle":
self.report("普通挑战记录由后台每2分钟自动核对;开启策略后续交已保存的结果,详细状态可查看战斗记录。")
return
self.report("没有未完成的扫荡记录")
return
if W.QMessageBox.question(self, "清除本地待处理记录", f"{pending['stage']}:{pending['phase']}\n请先在游戏内确认并处理该关卡。确认已处理后清除记录?") == W.QMessageBox.StandardButton.Yes:
self.engine.sweeper.state["pending"] = None
self.engine.sweeper.save()
self.render_maps()
def daily_tab(self):
self.daily_page = W.QWidget()
layout = W.QVBoxLayout(self.daily_page)
line = W.QHBoxLayout()
self.daily_enabled = W.QCheckBox("启用每日奖励领取")
line.addWidget(self.daily_enabled)
self.daily_checks = {}
for key, label in (("gift", "每日签到礼包"), ("check", "七日签到"), ("loop", "累计奖励"), ("vip", "VIP日奖"), ("mail", "邮件附件")):
check = W.QCheckBox(label)
check.setChecked(True)
check.toggled.connect(self.activity_settings_changed)
self.daily_checks[key] = check
line.addWidget(check)
line.addStretch()
layout.addLayout(line)
line = W.QHBoxLayout()
for label, function in (("刷新状态", self.refresh), ("领取勾选项目", self.claim_daily)):
button = W.QPushButton(label)
button.clicked.connect(function)
line.addWidget(button)
line.addStretch()
layout.addLayout(line)
self.daily_table = W.QTableWidget(0, 3)
self.daily_table.setHorizontalHeaderLabels(["项目 / 邮件", "状态", "奖励 / 附件"])
self.daily_table.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.daily_table.setAlternatingRowColors(True)
self.daily_table.horizontalHeader().setStretchLastSection(True)
self.daily_table.setColumnWidth(0, 280)
self.daily_table.setColumnWidth(1, 230)
layout.addWidget(self.daily_table, 1)
note = W.QLabel("刷新只更新状态。“领取勾选项目”立即处理当前可领奖励;勾选此页功能并开启顶部策略开关后,将自动领取。邮件仅领取附件。")
note.setWordWrap(True)
layout.addWidget(note)
self.tabs.addTab(self.daily_page, "每日事务")
self.daily_enabled.toggled.connect(self.activity_settings_changed)
def read_daily_policy(self):
return DailyPolicy(self.daily_enabled.isChecked(), [key for key, check in self.daily_checks.items() if check.isChecked()])
def render_daily(self):
rows = entries(self.catalog, self.engine.snapshot, self.engine.daily_ledger)
self.daily_table.setSortingEnabled(False)
self.daily_table.setRowCount(len(rows))
for i, row in enumerate(rows):
for j, text in enumerate((row.name, row.status, row.reward)):
item = table_item(text, j)
item.setToolTip(text)
self.daily_table.setItem(i, j, item)
self.daily_table.setSortingEnabled(True)
def claim_daily(self):
if self.busy:
self.report("请等待当前请求完成")
return
self.stop_workflow()
self.engine.daily_policy = self.read_daily_policy()
self.submit("daily_claim", self.engine.claim_daily)