546 lines
31 KiB
Python
546 lines
31 KiB
Python
"""Compact task pages; account workers prepare data, Qt only renders cached rows."""
|
||
import copy
|
||
from dataclasses import asdict, dataclass
|
||
from datetime import datetime, timedelta, timezone
|
||
import json
|
||
|
||
from PySide6 import QtCore as C, QtWidgets as W
|
||
|
||
from .native_widgets import ComboBox, IntegerInput, RowBatch
|
||
from .policy_io import checked_progression_policy
|
||
from .progression import ProgressionPolicy
|
||
from .table_widgets import set_value, table_item
|
||
from .battle_messages import battle_message
|
||
|
||
|
||
CATEGORIES = {"mainline": "主线", "sidequest": "支线", "commission": "委托", "event": "活动(暂不自动)",
|
||
"bond": "羁绊(暂不自动)", "unknown": "其他 / 未知"}
|
||
BATTLE_KINDS = {"mainline": "主线战斗", "sidequest": "支线战斗", "commission": "委托战斗",
|
||
"battle": "普通战斗", "map_battle": "地图战斗", "sweep": "扫荡", "hidden": "隐藏关卡战斗", "map_reward_event": "地图奖励事件",
|
||
"ordinary_stage": "普通关卡战斗", "task_battle": "任务战斗", "task_pass_stage": "任务通关战斗", "unknown": "其他 / 未知"}
|
||
BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event": "map_reward_event",
|
||
"reward_event": "map_reward_event", "normal": "battle", "map_sweep": "sweep"}
|
||
BATTLE_MODES = {"original": "原版运行时(以能力检查为准)", "experimental": "实验模拟(近似,未完整验证)"}
|
||
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中",
|
||
"ready": "待交付", "completed": "已完成", "complete": "已完成", "claimed": "已领奖",
|
||
"received": "进行中", "unlocked": "已解锁 / 待接取", "offered": "待接取", "locked": "未解锁", "finished": "已完成",
|
||
"ready_to_reward": "待领取任务奖励", "blocked": "受阻", "unsupported": "暂不支持", "unknown": "未知"}
|
||
CHINA_TIME = timezone(timedelta(hours=8))
|
||
STATE_FILTERS = (("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"),
|
||
("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态"))
|
||
STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked",
|
||
"ready": "ready_to_reward", "completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
|
||
CURRENT_STATES = {"received", "unlocked", "ready_to_reward"}
|
||
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件",
|
||
"completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对",
|
||
"abandoned_missing_hidden_id": "未完成,已放弃", "abandoned_unsettled_sweep": "未完成,已放弃", "cancelled_unsent_sweep": "未完成,已取消"}
|
||
|
||
|
||
def category(value):
|
||
return {"main": "mainline", "side": "sidequest", "sidequests": "sidequest", "commissions": "commission",
|
||
"主线": "mainline", "支线": "sidequest", "委托": "commission"}.get(value, value) if isinstance(value, str) else "unknown"
|
||
|
||
|
||
def display(value, empty="—"):
|
||
if value is None or value == "":
|
||
return empty
|
||
if isinstance(value, (dict, list, tuple)):
|
||
return json.dumps(value, ensure_ascii=False, sort_keys=True)
|
||
return str(value)
|
||
|
||
|
||
@dataclass
|
||
class ProgressionViews:
|
||
snapshot: object
|
||
tasks: list | None
|
||
records: list | None
|
||
message: str = ""
|
||
|
||
|
||
def prepare_progression_views(engine, *, tasks=True, records=True):
|
||
"""Worker boundary: getters may parse task data or read local battle records."""
|
||
task_reader = getattr(engine, "progression_rows", None)
|
||
record_reader = getattr(engine, "progression_records", None)
|
||
task_data = task_reader() if tasks and callable(task_reader) else []
|
||
record_data = record_reader() if records and callable(record_reader) else []
|
||
for name, rows in (("progression_rows", task_data), ("progression_records", record_data)):
|
||
if not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows):
|
||
raise TypeError(name + "() 必须返回 list[dict]")
|
||
task_rows, record_rows = [], []
|
||
for index, source in enumerate(task_data):
|
||
row = copy.deepcopy(source)
|
||
kind = category(row.get("category", "unknown"))
|
||
kind = kind if kind in CATEGORIES else "unknown"
|
||
raw_state = row.get("state")
|
||
state = display(raw_state, "未知")
|
||
lifecycle_state = STATE_ALIASES.get(state, state)
|
||
reason = battle_message(display(row.get("blocked_reason") or row.get("block_reason") or row.get("reason"), ""))
|
||
supported = row.get("supported")
|
||
support = "受阻:" + reason if reason else "已支持" if supported is True else "暂不支持" if supported is False else "支持状态未确认"
|
||
step = display(row.get("step_number")) + " / " + display(row.get("total_steps"))
|
||
battle = display(row.get("battle_kind"), "未确认")
|
||
battle = BATTLE_ALIASES.get(battle, battle)
|
||
location = row.get("location_text") or row.get("location") or row.get("position")
|
||
values = [display(row.get("task_type_id")), CATEGORIES[kind], display(row.get("name")), STATES.get(state, state), step,
|
||
display(location), display(row.get("requirement")), display(row.get("next_action")),
|
||
BATTLE_KINDS.get(battle, battle), support]
|
||
dialogue = display(row.get("dialogue") or row.get("dialogue_text") or row.get("dialogue_status"), "当前未提供对话内容")
|
||
detail = "\n".join(("任务:" + values[2] + " #" + values[0] + ";类别:" + values[1] + ";状态:" + values[3] + ";步骤:" + step,
|
||
"目标 / 位置:" + values[5] + ";NPC:" + display(row.get("npc_name")), "需求:" + values[6], "对话:" + dialogue,
|
||
"下一步:" + values[7] + ";战斗:" + values[8] + ";运行状态:" + display(row.get("status"), values[3]),
|
||
"支持状态 / 阻塞原因:" + support))
|
||
task_rows.append({"key": str(index), "category": kind, "state": raw_state, "lifecycle_state": lifecycle_state,
|
||
"values": values, "detail": detail,
|
||
"search": (" ".join(values) + " " + dialogue).casefold()})
|
||
for index, source in enumerate(record_data):
|
||
row = copy.deepcopy(source)
|
||
raw_kind = row.get("battle_kind") or row.get("kind") or row.get("context") or "unknown"
|
||
kind = BATTLE_ALIASES.get(raw_kind, raw_kind) if isinstance(raw_kind, str) else "unknown"
|
||
if row.get("outcome") == "event":
|
||
kind = "map_reward_event"
|
||
elif row.get("task_id") and kind == "battle":
|
||
kind = "task_battle"
|
||
elif row.get("kind") in ("sweep", "map_sweep") and kind != "hidden":
|
||
kind = "sweep"
|
||
stamp = row.get("finished_at") or row.get("started_at") or row.get("timestamp", row.get("time", row.get("at")))
|
||
if type(stamp) in (int, float) and 0 <= stamp <= 253402271999:
|
||
stamp = datetime.fromtimestamp(stamp, CHINA_TIME).strftime("%Y-%m-%d %H:%M:%S")
|
||
outcome = row.get("outcome") or row.get("status") or row.get("phase") or row.get("result")
|
||
if isinstance(outcome, dict):
|
||
outcome = outcome.get("outcome") or outcome.get("status")
|
||
outcome = display(outcome, "未确认")
|
||
values = [display(stamp), BATTLE_KINDS.get(kind, display(raw_kind)),
|
||
display(row.get("name") or row.get("task_type_id") or row.get("stage_id") or row.get("stage") or row.get("description")),
|
||
display(row.get("team")), OUTCOMES.get(outcome, outcome),
|
||
battle_message(display(row.get("blocked_reason") or row.get("block_reason") or row.get("message") or row.get("reason")))]
|
||
mode = row.get("battle_mode") or row.get("execution_mode")
|
||
mode = mode if isinstance(mode, str) else None
|
||
if mode == "experimental":
|
||
values[4] += "(实验近似)"
|
||
detail = "\n".join(("时间(北京时间):" + values[0], "上下文:" + values[1] + ";任务 / 地图:" + values[2],
|
||
"战斗模式:" + BATTLE_MODES.get(mode, "记录未标明"),
|
||
"队伍:" + values[3] + ";结果:" + values[4], "详情 / 阻塞原因:" + values[5], "奖励:" + display(row.get("reward"))))
|
||
if row.get("damage_profile") == "client_v4_x10":
|
||
detail += "\n伤害规则:我方对敌最终伤害 10 倍,单次最高 50000;角色属性保持原值"
|
||
elif row.get("damage_profile") == "original_1x":
|
||
detail += "\n伤害规则:原始 1 倍;角色属性保持原值"
|
||
elif row.get("damage_profile") is not None:
|
||
detail += "\n伤害规则未识别"
|
||
else:
|
||
detail += "\n旧记录未标明伤害倍率"
|
||
record_rows.append({"key": str(index), "category": kind if kind in BATTLE_KINDS else "unknown", "values": values,
|
||
"detail": detail, "search": " ".join(values).casefold()})
|
||
message = "" if callable(task_reader) else "当前引擎尚未提供任务读取;任务只展示,不自动推进"
|
||
return ProgressionViews(getattr(engine, "snapshot", None), task_rows if tasks else None, record_rows if records else None, message)
|
||
|
||
|
||
class CachedTable(W.QTableWidget):
|
||
"""Refresh owned items in short batches; never reinsert an existing Qt item."""
|
||
def __init__(self, headers, left_columns=()):
|
||
super().__init__(0, len(headers))
|
||
self.setHorizontalHeaderLabels(headers)
|
||
self.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
|
||
self.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
|
||
self.setSelectionMode(W.QAbstractItemView.SelectionMode.SingleSelection)
|
||
self.horizontalHeader().setStretchLastSection(True)
|
||
self.verticalHeader().setMinimumSectionSize(18)
|
||
self.verticalHeader().setDefaultSectionSize(22)
|
||
self.row_batch = RowBatch(self)
|
||
self.signature = None
|
||
self.details = {}
|
||
self.left_columns = {0, 1, *left_columns}
|
||
|
||
def set_rows(self, rows):
|
||
if self.signature == rows:
|
||
return
|
||
self.row_batch.stop()
|
||
self.signature = None
|
||
self.details = {row["key"]: row["detail"] for row in rows}
|
||
self.setSortingEnabled(False)
|
||
self.setRowCount(len(rows))
|
||
|
||
def apply(entry):
|
||
index, row = entry
|
||
for column, value in enumerate(row["values"]):
|
||
cell = self.item(index, column)
|
||
if cell is None:
|
||
cell = table_item(value, column)
|
||
self.setItem(index, column, cell)
|
||
else:
|
||
set_value(cell, column, value)
|
||
cell.setToolTip(value)
|
||
if column in self.left_columns:
|
||
cell.setTextAlignment(C.Qt.AlignmentFlag.AlignVCenter | C.Qt.AlignmentFlag.AlignLeft)
|
||
if column == 0:
|
||
cell.setData(C.Qt.ItemDataRole.UserRole, row["key"])
|
||
|
||
def finish():
|
||
self.signature = rows
|
||
self.setSortingEnabled(True)
|
||
self.itemSelectionChanged.emit()
|
||
|
||
self.row_batch.start(enumerate(rows), apply, finish)
|
||
|
||
|
||
class ProgressionPages:
|
||
def progression_tab(self):
|
||
self.progression_views = None
|
||
self.pending_progression_view = False
|
||
self.progression_generation = 0
|
||
self.progression_page = W.QWidget()
|
||
layout = W.QVBoxLayout(self.progression_page)
|
||
tools = W.QHBoxLayout()
|
||
self.progression_enabled = W.QCheckBox("启用自动主线策略")
|
||
self.progression_refresh_button = W.QPushButton("刷新任务 / 预览")
|
||
self.progression_refresh_button.clicked.connect(self.refresh_progression)
|
||
tools.addWidget(self.progression_enabled)
|
||
tools.addWidget(self.progression_refresh_button)
|
||
tools.addStretch()
|
||
layout.addLayout(tools)
|
||
self.progression_status = W.QLabel()
|
||
self.progression_status.setWordWrap(True)
|
||
layout.addWidget(self.progression_status)
|
||
self.progression_tabs = W.QTabWidget()
|
||
task_page = W.QWidget()
|
||
task_layout = W.QVBoxLayout(task_page)
|
||
filters = W.QHBoxLayout()
|
||
self.progression_filter = ComboBox()
|
||
for key, name in (("", "全部类别"), *CATEGORIES.items()):
|
||
self.progression_filter.addItem(name, key)
|
||
self.progression_filter.setCurrentIndex(self.progression_filter.findData("mainline"))
|
||
self.progression_state_filter = ComboBox()
|
||
for key, name in STATE_FILTERS:
|
||
self.progression_state_filter.addItem(name, key)
|
||
self.progression_search = W.QLineEdit()
|
||
self.progression_search.setPlaceholderText("按任务编号、名称、目标或阻塞原因筛选")
|
||
filters.addWidget(self.progression_filter)
|
||
filters.addWidget(self.progression_state_filter)
|
||
filters.addWidget(self.progression_search, 1)
|
||
task_layout.addLayout(filters)
|
||
self.progression_task_status = W.QLabel("默认只显示当前账号进行中、待接取和待领奖的主线任务")
|
||
self.progression_task_status.setWordWrap(True)
|
||
task_layout.addWidget(self.progression_task_status)
|
||
self.progression_table = CachedTable(["编号", "类别", "任务", "状态", "步骤", "目标 / 位置", "需求", "下一步", "战斗类型", "支持状态 / 阻塞原因"],
|
||
left_columns=(2, 5, 6, 7, 9))
|
||
self.progression_table.setColumnWidth(2, 180)
|
||
task_layout.addWidget(self.progression_table, 1)
|
||
self.progression_detail = W.QPlainTextEdit()
|
||
self.progression_detail.setReadOnly(True)
|
||
self.progression_detail.setMaximumHeight(108)
|
||
self.progression_detail.setPlaceholderText("选择任务,查看步骤、目标、对话、运行状态和阻塞原因")
|
||
task_layout.addWidget(self.progression_detail)
|
||
self.progression_tabs.addTab(task_page, "任务状态")
|
||
settings = W.QWidget()
|
||
form = W.QFormLayout(settings)
|
||
defaults = ProgressionPolicy()
|
||
groups = (("任务类别", (("mainline", "主线"), ("sidequests", "支线"), ("commissions", "委托(仅诊断)"))),
|
||
("任务流程", (("accept", "接取已确认的任务"), ("auto_dialogue", "自动推进已支持的对话"),
|
||
("repair_chain", "补全已确认的任务链"))),
|
||
("交付 / 通关", (("allow_items", "允许提交物品"), ("allow_monsters", "允许提交魔物"),
|
||
("allow_sweep", "允许用扫荡完成已通关目标"))))
|
||
for label, choices in groups:
|
||
line = W.QHBoxLayout()
|
||
for key, text in choices:
|
||
check = W.QCheckBox(text)
|
||
check.setChecked(getattr(defaults, key))
|
||
setattr(self, "progression_" + key, check)
|
||
line.addWidget(check)
|
||
line.addStretch()
|
||
form.addRow(label, line)
|
||
if hasattr(defaults, "auto_farm"):
|
||
self.progression_auto_farm = W.QCheckBox("自动收集任务材料 / 击杀目标")
|
||
self.progression_auto_farm.setChecked(defaults.auto_farm)
|
||
self.progression_auto_farm.setToolTip("允许规划器为已识别的材料或击杀缺口选择普通地图。\n"
|
||
"仍受任务规则、战斗能力、保留体力和顶部“开启 / 停止”限制;无法匹配的目标会显示原因。")
|
||
form.addRow("任务目标", self.progression_auto_farm)
|
||
self.progression_commissions.setToolTip("委托交付由“自动委托”页独立配置;此项只纳入任务诊断,不开启委托执行")
|
||
# Keep the combo for existing config/autosave glue; the GUI always simulates.
|
||
self.progression_battle_mode = ComboBox(settings)
|
||
for mode, label in BATTLE_MODES.items():
|
||
self.progression_battle_mode.addItem(label, mode)
|
||
self.progression_battle_mode.setCurrentIndex(self.progression_battle_mode.findData("experimental"))
|
||
self.progression_battle_mode.hide()
|
||
self.progression_team = ComboBox()
|
||
for team in ("teamA", "teamB", "teamC"):
|
||
self.progression_team.addItem(team, team)
|
||
form.addRow("推进战斗队伍", self.progression_team)
|
||
for key, label, maximum in (("reserve_ti", "保留体力", 1_000_000_000), ("max_money", "单次交付金币上限(0=不交金币)", 1_000_000_000),
|
||
("stop_after_loss", "连续失败后停止次数", 999)):
|
||
widget = IntegerInput()
|
||
widget.setRange(1 if key == "stop_after_loss" else 0, maximum)
|
||
widget.setValue(getattr(defaults, key))
|
||
setattr(self, "progression_" + key, widget)
|
||
form.addRow(label, widget)
|
||
self.progression_item_reserves = W.QLineEdit()
|
||
self.progression_item_reserves.setPlaceholderText("物品编号:保留数量,多个用英文逗号分隔")
|
||
form.addRow("交付后至少保留", self.progression_item_reserves)
|
||
note = W.QLabel("勾选功能后,使用顶部绿色“开启”运行。支持状态以任务列表为准;未知状态不会自动执行。\n任务列表区分主线 / 支线 / 委托;战斗记录区分普通战斗、扫荡和地图奖励事件。未支持的步骤显示原因。\n桌面模拟保持原始属性,仅将我方对敌最终伤害调整为 10 倍、上限 50000。")
|
||
note.setWordWrap(True)
|
||
form.addRow(note)
|
||
scroll = W.QScrollArea()
|
||
scroll.setWidgetResizable(True)
|
||
scroll.setFrameShape(W.QFrame.Shape.NoFrame)
|
||
scroll.setWidget(settings)
|
||
self.progression_tabs.addTab(scroll, "推进策略")
|
||
layout.addWidget(self.progression_tabs, 1)
|
||
self.tabs.addTab(self.progression_page, "自动主线")
|
||
self.progression_filter.currentIndexChanged.connect(self.render_progression_filters)
|
||
self.progression_state_filter.currentIndexChanged.connect(self.render_progression_filters)
|
||
self.progression_search.textChanged.connect(self.render_progression_filters)
|
||
self.progression_table.itemSelectionChanged.connect(self.progression_selection_changed)
|
||
self.progression_enabled.toggled.connect(self.progression_settings_changed)
|
||
self.update_progression_status()
|
||
|
||
def battle_records_tab(self):
|
||
self.battle_records_page = W.QWidget()
|
||
layout = W.QVBoxLayout(self.battle_records_page)
|
||
tools = W.QHBoxLayout()
|
||
self.battle_records_filter = ComboBox()
|
||
for key, name in (("", "全部上下文"), *BATTLE_KINDS.items()):
|
||
self.battle_records_filter.addItem(name, key)
|
||
self.battle_records_search = W.QLineEdit()
|
||
self.battle_records_search.setPlaceholderText("按任务、地图、结果或阻塞原因筛选")
|
||
refresh = W.QPushButton("刷新本地记录")
|
||
refresh.clicked.connect(self.refresh_progression_records)
|
||
for widget in (self.battle_records_filter, self.battle_records_search, refresh):
|
||
tools.addWidget(widget)
|
||
layout.addLayout(tools)
|
||
self.battle_records_status = W.QLabel("尚无已读取的战斗记录;地图奖励事件会单独标明,结果以实际记录为准")
|
||
self.battle_records_status.setWordWrap(True)
|
||
layout.addWidget(self.battle_records_status)
|
||
self.battle_records_table = CachedTable(["时间(北京时间)", "上下文", "任务 / 地图", "队伍", "结果", "详情 / 阻塞原因"], left_columns=(2, 5))
|
||
for column, width in enumerate((158, 124, 140, 70, 95)):
|
||
self.battle_records_table.setColumnWidth(column, width)
|
||
layout.addWidget(self.battle_records_table, 1)
|
||
self.battle_record_detail = W.QPlainTextEdit()
|
||
self.battle_record_detail.setReadOnly(True)
|
||
self.battle_record_detail.setMaximumHeight(108)
|
||
self.battle_record_detail.setPlaceholderText("选择记录查看引擎提供的详情")
|
||
layout.addWidget(self.battle_record_detail)
|
||
self.tabs.addTab(self.battle_records_page, "战斗记录")
|
||
self.battle_records_filter.currentIndexChanged.connect(self.render_progression)
|
||
self.battle_records_search.textChanged.connect(self.render_progression)
|
||
self.battle_records_table.itemSelectionChanged.connect(self.progression_selection_changed)
|
||
|
||
def progression_settings_changed(self, *args):
|
||
if self.loading_config or self.closed:
|
||
return
|
||
if self.sender() is self.progression_enabled and not self.progression_enabled.isChecked():
|
||
self.cancel_progression()
|
||
self.update_progression_status()
|
||
self.settings_changed()
|
||
|
||
def cancel_progression(self):
|
||
self.progression_generation += 1
|
||
cancel = getattr(self.engine, "cancel_progression", None)
|
||
if callable(cancel):
|
||
cancel()
|
||
|
||
def read_progression_policy(self):
|
||
value = {}
|
||
for key, default in asdict(ProgressionPolicy()).items():
|
||
widget = getattr(self, "progression_" + key)
|
||
if key == "battle_mode":
|
||
# Legacy GUI glue may restore the hidden combo after loading.
|
||
value[key] = "experimental"
|
||
elif key == "item_reserves":
|
||
reserves = {}
|
||
for entry in widget.text().split(","):
|
||
if entry.strip():
|
||
item_id, count = entry.split(":")
|
||
reserves[item_id.strip()] = int(count.strip())
|
||
value[key] = reserves
|
||
elif isinstance(widget, W.QComboBox):
|
||
value[key] = widget.currentData()
|
||
else:
|
||
value[key] = widget.isChecked() if type(default) is bool else widget.value()
|
||
return checked_progression_policy(value)
|
||
|
||
def load_progression_policy(self, policy):
|
||
for key, value in asdict(policy).items():
|
||
if key == "battle_mode":
|
||
value = "experimental"
|
||
widget = getattr(self, "progression_" + key)
|
||
blocker = C.QSignalBlocker(widget)
|
||
if key == "item_reserves":
|
||
widget.setText(",".join(f"{item_id}:{count}" for item_id, count in value.items()))
|
||
elif isinstance(widget, W.QComboBox):
|
||
index = widget.findData(value)
|
||
if index < 0:
|
||
if key != "team":
|
||
raise ValueError("不支持的策略选项:" + key)
|
||
widget.addItem(value + "(当前账号未找到)", value)
|
||
index = widget.findData(value)
|
||
widget.setCurrentIndex(index)
|
||
elif type(value) is bool:
|
||
widget.setChecked(value)
|
||
else:
|
||
widget.setValue(value)
|
||
del blocker
|
||
self.update_progression_status()
|
||
|
||
def refresh_progression_teams(self, snapshot):
|
||
"""Keep imported selections visible until this account confirms a team."""
|
||
selected = self.progression_team.currentData() or "teamA"
|
||
names = ["teamA", "teamB", "teamC"]
|
||
confirmed = set()
|
||
for team in snapshot.raw.get("teams", []):
|
||
name = team.get("teamName")
|
||
if team.get("teamType") == "battleTeam" and isinstance(name, str) and name:
|
||
confirmed.add(name)
|
||
if name not in names:
|
||
names.append(name)
|
||
if selected not in names:
|
||
names.append(selected)
|
||
options = [(name + "(当前账号未找到)" if name == selected and name not in confirmed and name not in ("teamA", "teamB", "teamC") else name, name)
|
||
for name in names]
|
||
widget = self.progression_team
|
||
if [(widget.itemText(i), widget.itemData(i)) for i in range(widget.count())] != options:
|
||
blocker = C.QSignalBlocker(widget)
|
||
widget.clear()
|
||
for label, name in options:
|
||
widget.addItem(label, name)
|
||
widget.setCurrentIndex(widget.findData(selected))
|
||
del blocker
|
||
|
||
def update_progression_status(self):
|
||
if not hasattr(self, "progression_status"):
|
||
return
|
||
active = self.strategy_toggle.isChecked() and self.progression_enabled.isChecked()
|
||
text = "自动主线已开启" if active else "策略已停止;顶部“开启”后执行勾选功能" if self.progression_enabled.isChecked() else "自动主线未启用"
|
||
text += ";战斗保持原始属性,实验模拟中我方对敌最终伤害为 10 倍、上限 50000,等待计算出的战斗时长后提交(近似推演,结果以实际记录为准)"
|
||
if not callable(getattr(self.engine, "refresh_progression", None)):
|
||
text += ";当前引擎尚未接入任务刷新"
|
||
if not callable(getattr(self.engine, "run_progression_once", None)):
|
||
text += ";当前引擎尚未接入自动推进"
|
||
if self.progression_views and self.progression_views.message:
|
||
text += ";" + self.progression_views.message
|
||
self.progression_status.setText(text)
|
||
|
||
def refresh_progression(self, checked=False):
|
||
if self.closed:
|
||
return
|
||
if self.busy:
|
||
self.pending_refresh = self.progression_page
|
||
self.statusBar().showMessage("当前请求完成后刷新任务")
|
||
return
|
||
refresh = getattr(self.engine, "refresh_progression", None)
|
||
if not callable(refresh):
|
||
self.report("当前引擎尚未提供任务刷新;请等待功能接入")
|
||
self.request_progression_views(force=True)
|
||
return
|
||
try:
|
||
self.update_policy()
|
||
except ValueError as error:
|
||
self.stop_workflow()
|
||
self.report("主线策略输入有误:" + str(error))
|
||
return
|
||
self.run_job("progression_refresh", refresh)
|
||
|
||
def run_progression_once(self):
|
||
"""Explicit one-step entry; it never changes the global execution switch."""
|
||
if self.closed or self.busy:
|
||
return
|
||
if not self.strategy_toggle.isChecked() or not self.progression_enabled.isChecked():
|
||
self.report("自动主线已停止;请先勾选策略并开启顶部开关")
|
||
return
|
||
run = getattr(self.engine, "run_progression_once", None)
|
||
if not callable(run):
|
||
self.report("当前引擎尚未提供自动推进")
|
||
return
|
||
try:
|
||
self.update_policy()
|
||
except ValueError as error:
|
||
self.stop_workflow()
|
||
self.report("主线策略输入有误:" + str(error))
|
||
return
|
||
self.engine.auto = self.monitoring and self.strategy_toggle.isChecked()
|
||
engine, generation = self.engine, self.progression_generation
|
||
def execute():
|
||
if generation != self.progression_generation or not engine.auto:
|
||
return engine.snapshot, [], "任务推进已取消;未开始执行"
|
||
return run()
|
||
self.run_job("progression_run", execute)
|
||
|
||
def refresh_progression_records(self, checked=False):
|
||
self.request_progression_views(force=True)
|
||
|
||
def clear_progression_views(self):
|
||
self.progression_views = None
|
||
self.pending_progression_view = False
|
||
for widget in (self.progression_table, self.battle_records_table):
|
||
widget.row_batch.stop()
|
||
widget.set_rows([])
|
||
self.progression_detail.clear()
|
||
self.battle_record_detail.clear()
|
||
self.progression_task_status.setText("默认只显示当前账号进行中、待接取和待领奖的主线任务")
|
||
self.update_progression_status()
|
||
|
||
def accept_progression_views(self, views):
|
||
previous = self.progression_views
|
||
if previous and previous.snapshot is views.snapshot:
|
||
if views.tasks is None:
|
||
views.tasks = previous.tasks
|
||
if views.records is None:
|
||
views.records = previous.records
|
||
self.progression_views = views
|
||
|
||
def request_progression_views(self, *, force=False):
|
||
if self.closed or self.engine.snapshot is None:
|
||
return
|
||
tasks = self.tabs.currentWidget() is not self.battle_records_page
|
||
cached = self.progression_views
|
||
if not force and cached and cached.snapshot is self.engine.snapshot and (cached.tasks if tasks else cached.records) is not None:
|
||
return
|
||
if self.busy:
|
||
self.pending_progression_view = True
|
||
return
|
||
self.pending_progression_view = False
|
||
engine = self.engine
|
||
self.run_job("progression_view", lambda: prepare_progression_views(engine, tasks=tasks, records=not tasks))
|
||
|
||
def render_progression_filters(self, *args):
|
||
self.render_progression(request_missing=False)
|
||
|
||
def render_progression(self, *args, request_missing=True):
|
||
if self.closed or not self.presentation_active:
|
||
return
|
||
page = self.tabs.currentWidget()
|
||
if page not in (self.progression_page, self.battle_records_page):
|
||
return
|
||
views = self.progression_views
|
||
tasks = page is self.progression_page
|
||
if request_missing and (views is None or views.snapshot is not self.engine.snapshot or (views.tasks if tasks else views.records) is None):
|
||
self.request_progression_views()
|
||
table = self.progression_table if tasks else self.battle_records_table
|
||
rows = ((views.tasks if tasks else views.records) or []) if views else []
|
||
selected = self.progression_filter.currentData() if tasks else self.battle_records_filter.currentData()
|
||
query = (self.progression_search.text() if tasks else self.battle_records_search.text()).strip().casefold()
|
||
state = self.progression_state_filter.currentData()
|
||
def matches(row):
|
||
if selected and row["category"] != selected:
|
||
return False
|
||
if query and query not in row["search"]:
|
||
return False
|
||
if not tasks or not state:
|
||
return True
|
||
lifecycle_state = row["lifecycle_state"]
|
||
return lifecycle_state in CURRENT_STATES if state == "current" else lifecycle_state == state
|
||
visible = [row for row in rows if matches(row)]
|
||
table.set_rows(visible)
|
||
if tasks:
|
||
self.progression_task_status.setText(f"显示 {len(visible)} / {len(rows)} 条任务" if visible else
|
||
f"没有符合当前类别、状态和搜索条件的任务(共 {len(rows)} 条)")
|
||
else:
|
||
self.battle_records_status.setText(f"已读取 {len(rows)} 条记录,显示 {len(visible)} 条;战斗、扫荡和地图奖励事件分别标记" if rows else
|
||
"尚无已读取的战斗记录;未记录结果不代表战斗成功")
|
||
self.update_progression_status()
|
||
self.progression_selection_changed()
|
||
|
||
def progression_selection_changed(self):
|
||
for table, detail in ((self.progression_table, self.progression_detail), (self.battle_records_table, self.battle_record_detail)):
|
||
item = table.item(table.currentRow(), 0)
|
||
text = table.details.get(item.data(C.Qt.ItemDataRole.UserRole), "") if item else ""
|
||
if detail.toPlainText() != text:
|
||
detail.setPlainText(text)
|