2219 lines
117 KiB
Python
2219 lines
117 KiB
Python
from __future__ import annotations
|
||
from dataclasses import asdict
|
||
import copy
|
||
import json
|
||
import random
|
||
from pathlib import Path
|
||
import sys
|
||
import time
|
||
|
||
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
|
||
|
||
from .api import ApiError, Client, Session, DEFAULT_KEY, server_entries
|
||
from .engine import Engine
|
||
from .model import Catalog, Policy, WIKI, duration
|
||
from .egg_rules_gui import EggTable
|
||
from .management import expansion_quote, manual_monster_actions
|
||
from .native_widgets import ComboBox, SpinBox, DoubleSpinBox, use_native_scrollbars
|
||
from .login import PasswordLogin, device_id, server_labels
|
||
from .quests import QuestPolicy
|
||
from .daily import DailyPolicy
|
||
from .sweeping import SweepPolicy
|
||
from .progression import ProgressionPolicy
|
||
from .activity_gui import ActivityPages
|
||
from .progression_gui import ProgressionPages, prepare_progression_views
|
||
from .battle_messages import battle_message
|
||
from .presentation import Presented, prepare_views, monster_rows
|
||
from .credentials import CredentialStore
|
||
from .debug import TraceLog
|
||
from .debug_window import DebugWindow
|
||
from .sessions import SessionStore, identity
|
||
from .inventory_gui import ITEM_TYPES, InventoryTable
|
||
from .ranch_gui import RanchView
|
||
from .policy_io import portable_config, import_config, checked_progression_policy
|
||
from .table_widgets import table_item
|
||
from .stage_cache import StageCache
|
||
from .drop_statistics import SweepStatistics
|
||
from .statistics_gui import StatisticsPage
|
||
|
||
APP_VERSION = "1.2.0.dev1"
|
||
GAME_VERSION = "1.9.68"
|
||
|
||
ROOT = Path(sys.executable).parent if getattr(sys, "frozen", False) else Path(__file__).resolve().parent.parent
|
||
STATE = ROOT / "local_state" / "ranch_helper"
|
||
|
||
|
||
class Signals(C.QObject):
|
||
result = C.Signal(str, object)
|
||
error = C.Signal(str)
|
||
done = C.Signal()
|
||
|
||
|
||
class Job(C.QRunnable):
|
||
def __init__(self, kind, function):
|
||
super().__init__()
|
||
self.kind, self.function, self.signals = kind, function, Signals()
|
||
|
||
def run(self):
|
||
try:
|
||
self.signals.result.emit(self.kind, self.function())
|
||
except Exception as error:
|
||
# Network errors are deliberately sanitized in the API layer.
|
||
self.signals.error.emit(str(error))
|
||
finally:
|
||
self.signals.done.emit()
|
||
|
||
|
||
def spin(low, high, value, decimals=False):
|
||
widget = DoubleSpinBox() if decimals else SpinBox()
|
||
widget.setRange(low, high)
|
||
widget.setValue(value)
|
||
return widget
|
||
|
||
|
||
def combo(options):
|
||
widget = ComboBox()
|
||
for text, data in options:
|
||
widget.addItem(text, data)
|
||
return widget
|
||
|
||
|
||
def table(headers):
|
||
widget = W.QTableWidget(0, len(headers))
|
||
widget.setHorizontalHeaderLabels(headers)
|
||
widget.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
|
||
widget.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
|
||
widget.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents)
|
||
widget.horizontalHeader().setStretchLastSection(True)
|
||
widget.verticalHeader().setMinimumSectionSize(18)
|
||
widget.verticalHeader().setDefaultSectionSize(22)
|
||
return widget
|
||
|
||
|
||
def compact_layouts(widget):
|
||
for layout in widget.findChildren(W.QLayout):
|
||
owner = layout.parentWidget()
|
||
if owner is not None and owner.window().windowType() == C.Qt.WindowType.Popup:
|
||
continue
|
||
layout.setContentsMargins(4, 4, 4, 4)
|
||
layout.setSpacing(4)
|
||
if isinstance(layout, W.QFormLayout):
|
||
layout.setVerticalSpacing(4)
|
||
layout.setHorizontalSpacing(6)
|
||
|
||
|
||
def fill_table(widget, rows, sorting=True):
|
||
widget.setSortingEnabled(False)
|
||
widget.setRowCount(len(rows))
|
||
for i, row in enumerate(rows):
|
||
for j, value in enumerate(row):
|
||
item = table_item(value, j)
|
||
widget.setItem(i, j, item)
|
||
widget.setSortingEnabled(sorting)
|
||
|
||
|
||
class Window(ProgressionPages, ActivityPages, W.QMainWindow):
|
||
network_event = C.Signal(object)
|
||
profile_changed = C.Signal(str)
|
||
|
||
def __init__(self, state_root=None):
|
||
super().__init__()
|
||
use_native_scrollbars()
|
||
self.profile_root = Path(state_root or STATE).resolve()
|
||
self.state = self.profile_root
|
||
self.session_store = SessionStore(self.profile_root)
|
||
self.session_label = ""
|
||
self.active_identity = None
|
||
self.pending_refresh = None
|
||
self.pending_execute = False
|
||
self.close_after_job = False
|
||
self.closed = False
|
||
self.loading_config = False
|
||
self.connection_guard = None
|
||
self.login_guard = None
|
||
if not G.QFontDatabase.families():
|
||
font_id = G.QFontDatabase.addApplicationFont("C:/Windows/Fonts/msyh.ttc")
|
||
families = G.QFontDatabase.applicationFontFamilies(font_id)
|
||
if families:
|
||
W.QApplication.instance().setFont(G.QFont(families[-1], 9))
|
||
self.setWindowTitle("牧羊人之心牧场辅助")
|
||
font = self.font()
|
||
font.setPointSizeF(8.5)
|
||
self.setFont(font)
|
||
self.resize(1060, 680)
|
||
self.credentials = CredentialStore(self.profile_root)
|
||
self.trace = TraceLog(self.profile_root, on_event=self.network_event.emit)
|
||
self.debug_window = DebugWindow(self.trace, self)
|
||
self.network_event.connect(self.on_network_event)
|
||
self.catalog, self.pool = Catalog(), C.QThreadPool(self)
|
||
self.pool.setMaxThreadCount(1)
|
||
self.engine = Engine(self.catalog)
|
||
self.busy, self.monitoring = False, False
|
||
self.active_job = None
|
||
self.pending_preview = False
|
||
self.pending_policy = None
|
||
self.logout_phase = None
|
||
self.pending_monster_view = False
|
||
self.monster_data_pending = False
|
||
self.pending_schedule = False
|
||
self.monster_view_visible = False
|
||
self.presentation_active = True
|
||
self.engine.presentation_active = True
|
||
self.engine.progression_view_active = False
|
||
self.latest_render = None
|
||
self.prepared_views = None
|
||
self.next_poll = 0
|
||
self.next_hatch = float("inf")
|
||
self.next_gift = float("inf")
|
||
self.hatch_timer = C.QTimer(self)
|
||
self.hatch_timer.setSingleShot(True)
|
||
self.hatch_timer.setTimerType(C.Qt.TimerType.PreciseTimer)
|
||
self.hatch_timer.timeout.connect(self.schedule)
|
||
self.client_pending = None
|
||
self.password_login_result = None
|
||
self.egg_rules = {}
|
||
self.feed_targets = {}
|
||
self.gift_targets = {}
|
||
self.gift_items = {}
|
||
central = W.QWidget()
|
||
layout = W.QVBoxLayout(central)
|
||
self.setCentralWidget(central)
|
||
toolbar = W.QHBoxLayout()
|
||
self.mode = W.QLabel("未登录")
|
||
self.summary = W.QLabel()
|
||
self.data_summary = W.QLabel("等待读取培育室、背包和牧场状态")
|
||
self.interval = combo([("随机30秒", 30), ("随机60秒", 60), ("随机2分钟", 120), ("随机5分钟", 300)])
|
||
self.interval.setToolTip("整体刷新完成后,从0到所选上限随机等待。空坑装填独立随机1~2秒;孵化/成长到期会单独同步。")
|
||
self.strategy_toggle = W.QPushButton("开启")
|
||
self.strategy_toggle.setCheckable(True)
|
||
self.strategy_toggle.setMinimumWidth(76)
|
||
self.strategy_toggle.setStyleSheet("""
|
||
QPushButton { background-color: #20743a; color: white; border: 1px solid #185b2d;
|
||
border-radius: 3px; padding: 4px 12px; font-weight: 600; }
|
||
QPushButton:hover { background-color: #1b6332; }
|
||
QPushButton:pressed { background-color: #174e28; }
|
||
QPushButton:checked { background-color: #b3261e; border-color: #8f1e18; }
|
||
QPushButton:checked:hover { background-color: #992019; }
|
||
QPushButton:checked:pressed { background-color: #7e1c16; }
|
||
QPushButton:focus { border: 1px dashed white; }
|
||
QPushButton:disabled { background-color: #686868; border-color: #686868; color: white; }
|
||
""")
|
||
self.set_strategy_checked(False)
|
||
self.strategy_toggle.toggled.connect(self.strategy_changed)
|
||
refresh = W.QPushButton("刷新 / 预览策略")
|
||
refresh.clicked.connect(self.refresh)
|
||
debug_button = W.QPushButton("调试窗口")
|
||
debug_button.clicked.connect(self.show_debug)
|
||
self.show_log = W.QPushButton("隐藏日志")
|
||
self.show_log.setCheckable(True)
|
||
self.show_log.setChecked(True)
|
||
for widget in (self.summary, self.interval, self.strategy_toggle, refresh, debug_button, self.show_log):
|
||
toolbar.addWidget(widget)
|
||
toolbar.addStretch()
|
||
layout.addLayout(toolbar)
|
||
layout.addWidget(self.data_summary)
|
||
self.tabs = W.QTabWidget()
|
||
self.tabs.setMinimumHeight(160)
|
||
tab_font = self.font()
|
||
tab_font.setPointSizeF(8)
|
||
self.tabs.tabBar().setFont(tab_font)
|
||
self.connection_tab()
|
||
self.slots = table(["坑位", "坑ID", "开启状态", "魔物", "星级", "阶段", "剩余时间", "资质 攻/防/血/敏", "建议"])
|
||
self.slots.sortItems(0, C.Qt.SortOrder.AscendingOrder)
|
||
self.eggs = EggTable(self.catalog)
|
||
self.eggs.rules_changed.connect(self.egg_rules_changed)
|
||
self.monsters = RanchView(self.catalog)
|
||
self.monster_render_timer = self.monsters.row_batch
|
||
self.slot_page = W.QWidget()
|
||
slot_layout = W.QVBoxLayout(self.slot_page)
|
||
self.slot_status = W.QLabel()
|
||
slot_layout.addWidget(self.slot_status)
|
||
slot_tools = W.QHBoxLayout()
|
||
for label, currency in (("开启选中普通坑位(金币)", "money"), ("开启选中普通坑位(氪金)", "ke")):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("stack", currency))
|
||
slot_tools.addWidget(button)
|
||
slot_tools.addStretch()
|
||
slot_layout.addLayout(slot_tools)
|
||
slot_layout.addWidget(self.slots)
|
||
self.tabs.addTab(self.slot_page, "培育室")
|
||
self.egg_page = W.QWidget()
|
||
egg_layout = W.QVBoxLayout(self.egg_page)
|
||
rule_note = W.QLabel("只孵勾选的蛋;优先级数字越小越先。孵出后可选派遣、喂养或保留。\n可用蛋低于“低于补货”时,从该行市场补货;0表示不补货。市场随机出蛋,补货受金币和每日额度限制。")
|
||
rule_note.setWordWrap(True)
|
||
egg_layout.addWidget(rule_note)
|
||
egg_buttons = W.QHBoxLayout()
|
||
for label, function in (("添加无库存蛋规则", self.add_egg_rule), ("刷新背包", self.refresh)):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(function)
|
||
egg_buttons.addWidget(button)
|
||
egg_buttons.addStretch()
|
||
egg_layout.addLayout(egg_buttons)
|
||
egg_layout.addWidget(self.eggs)
|
||
self.inventory_tabs = W.QTabWidget()
|
||
self.inventory_tabs.addTab(self.egg_page, "魔物蛋")
|
||
self.inventory_tables = {}
|
||
for category, label in ITEM_TYPES:
|
||
if category in (0, 6):
|
||
continue
|
||
item_page = W.QWidget()
|
||
item_page.setProperty("inventory_category", category)
|
||
item_layout = W.QVBoxLayout(item_page)
|
||
search = W.QLineEdit()
|
||
search.setPlaceholderText("按物品名称或类型编号筛选")
|
||
inventory = InventoryTable(self.catalog)
|
||
inventory.set_filter(category=category)
|
||
inventory.gifts_changed.connect(self.gift_items_changed)
|
||
search.textChanged.connect(lambda text, category=category: self.filter_inventory(category, text))
|
||
item_layout.addWidget(search)
|
||
item_layout.addWidget(inventory)
|
||
self.inventory_tables[category] = inventory
|
||
self.inventory_tabs.addTab(item_page, label)
|
||
self.tabs.addTab(self.inventory_tabs, "背包")
|
||
self.egg_page = self.inventory_tabs
|
||
self.egg_rules_page = self.inventory_tabs.widget(0)
|
||
self.monster_page = W.QWidget()
|
||
monster_layout = W.QVBoxLayout(self.monster_page)
|
||
monster_tools = W.QHBoxLayout()
|
||
self.lock_monsters = W.QPushButton("锁定选中")
|
||
self.unlock_monsters = W.QPushButton("解锁选中")
|
||
self.lock_monsters.clicked.connect(lambda: self.change_monster_lock(True))
|
||
self.unlock_monsters.clicked.connect(lambda: self.change_monster_lock(False))
|
||
self.monster_selection = W.QLabel("选择魔物后可锁定 / 解锁,也可右键操作")
|
||
self.monster_view = combo([("按牧场分组", 1), ("全部魔物", 0)])
|
||
self.monster_room = combo([("全部牧场", 0)])
|
||
for widget in (self.monster_view, self.monster_room, self.lock_monsters, self.unlock_monsters, self.monster_selection):
|
||
monster_tools.addWidget(widget)
|
||
for label, currency in (("新建牧场(金币)", "money"), ("新建牧场(氪金)", "ke")):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
|
||
monster_tools.addWidget(button)
|
||
monster_tools.addStretch()
|
||
monster_layout.addLayout(monster_tools)
|
||
detail_note = W.QLabel("勾选“喂养目标”并设置优先级(数字小的先喂);当前突破上限满级后转下一个目标。参考属性含等级、潜能、好感和升星,不含装备、羁绊或全局加成。")
|
||
detail_note.setWordWrap(True)
|
||
monster_layout.addWidget(detail_note)
|
||
self.ranch_view = self.monsters
|
||
monster_layout.addWidget(self.ranch_view)
|
||
self.monsters.itemSelectionChanged.connect(self.update_monster_actions)
|
||
self.monsters.monster_activated.connect(self.show_monster_detail)
|
||
self.monsters.feed_changed.connect(self.monster_feed_changed)
|
||
self.monsters.gift_changed.connect(self.monster_gift_changed)
|
||
self.room_page = self.monster_page
|
||
self.tabs.addTab(self.room_page, "牧场")
|
||
self.policy_page = self.policy_tab(embedded=True)
|
||
self.gifting_tab()
|
||
self.automation_tab()
|
||
self.progression_tab()
|
||
self.battle_records_tab()
|
||
self.yield_tab()
|
||
self.quests_tab()
|
||
self.maps_tab()
|
||
self.analysis_page = StatisticsPage(self.catalog)
|
||
self.analysis_page.refresh_requested.connect(self.refresh_analysis)
|
||
self.tabs.addTab(self.analysis_page, "数据分析")
|
||
self.daily_tab()
|
||
self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"])
|
||
self.tabs.addTab(self.plans, "执行计划")
|
||
order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page,
|
||
self.daily_page, self.automation_page, self.progression_page, self.battle_records_page, self.gift_page,
|
||
self.quests_table.parentWidget(), self.map_page, self.analysis_page,
|
||
self.plans, self.yields.parentWidget()]
|
||
for page in order:
|
||
self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page)))
|
||
self.monster_view.currentIndexChanged.connect(self.monster_view_changed)
|
||
self.monster_room.currentIndexChanged.connect(self.monster_view_changed)
|
||
self.monster_view.setCurrentIndex(self.monster_view.findData(0))
|
||
self.inventory_tabs.currentChanged.connect(self.render_current_page)
|
||
self.inventory_tabs.setCurrentIndex(0)
|
||
self.log = W.QPlainTextEdit()
|
||
self.log.setReadOnly(True)
|
||
self.log.setMaximumBlockCount(600)
|
||
self.log.setMinimumHeight(36)
|
||
self.log_sizes = [420, 140]
|
||
self.log_splitter = W.QSplitter(C.Qt.Orientation.Vertical)
|
||
self.log_splitter.setHandleWidth(6)
|
||
self.log_splitter.setChildrenCollapsible(False)
|
||
self.log_splitter.addWidget(self.tabs)
|
||
self.log_splitter.addWidget(self.log)
|
||
self.log_splitter.handle(1).setToolTip("上下拖动以调整页面和日志的高度")
|
||
self.log_splitter.setStretchFactor(0, 1)
|
||
self.log_splitter.setStretchFactor(1, 0)
|
||
self.log_splitter.setSizes(self.log_sizes)
|
||
self.log_splitter.splitterMoved.connect(self.remember_log_sizes)
|
||
self.show_log.toggled.connect(self.toggle_log)
|
||
layout.addWidget(self.log_splitter, 1)
|
||
compact_layouts(central)
|
||
self.update_monster_actions()
|
||
self.default_config = self.config_value()
|
||
self.load_config()
|
||
self.load_login_info()
|
||
self.remember_password.toggled.connect(self.save_login_info)
|
||
self.account.editingFinished.connect(lambda: self.save_login_info(quiet=True))
|
||
self.password.editingFinished.connect(lambda: self.save_login_info(quiet=True))
|
||
self.render_catalog()
|
||
self.install_refresh_menus()
|
||
self.tabs.currentChanged.connect(self.render_current_page)
|
||
self.interval.currentIndexChanged.connect(self.poll_interval_changed)
|
||
self.setup_autosave()
|
||
self.reload_saved_sessions()
|
||
self.timer = C.QTimer(self)
|
||
self.timer.timeout.connect(self.schedule)
|
||
self.timer.start(500)
|
||
C.QTimer.singleShot(0, self.refresh)
|
||
|
||
def connection_tab(self):
|
||
tab, form = W.QWidget(), W.QFormLayout()
|
||
tab.setLayout(form)
|
||
self.account = W.QLineEdit()
|
||
self.password = W.QLineEdit()
|
||
self.password.setEchoMode(W.QLineEdit.EchoMode.Password)
|
||
self.remember_password = W.QCheckBox("记住账号和密码")
|
||
self.remember_password.setChecked(True)
|
||
show_password = W.QCheckBox("显示密码")
|
||
show_password.toggled.connect(lambda show: self.password.setEchoMode(W.QLineEdit.EchoMode.Normal if show else W.QLineEdit.EchoMode.Password))
|
||
login_options = W.QHBoxLayout()
|
||
for widget in (self.remember_password, show_password):
|
||
login_options.addWidget(widget)
|
||
login_options.addStretch()
|
||
self.login_button = W.QPushButton("账号密码登录并获取区服")
|
||
self.login_button.clicked.connect(self.password_login)
|
||
self.server_list = ComboBox()
|
||
self.enter_button = W.QPushButton("进入选中区服")
|
||
self.enter_button.clicked.connect(self.enter_password_server)
|
||
self.enter_button.setEnabled(False)
|
||
form.addRow("第一弹渠道账号", self.account)
|
||
form.addRow("密码", self.password)
|
||
form.addRow(login_options)
|
||
form.addRow(self.login_button)
|
||
server_row = W.QHBoxLayout()
|
||
server_row.addWidget(self.server_list, 1)
|
||
server_row.addWidget(self.enter_button)
|
||
form.addRow("区服 / 角色", server_row)
|
||
self.login_status = W.QLabel("未登录:账号验证 → 获取官方区服 → 选择区服 → 进入区服 → 读取角色")
|
||
self.login_status.setWordWrap(True)
|
||
form.addRow(self.login_status)
|
||
self.saved_sessions = ComboBox()
|
||
self.saved_sessions.setPlaceholderText("成功读取角色后自动保存会话")
|
||
restore = W.QPushButton("恢复选中会话(无需重输密码)")
|
||
restore.clicked.connect(self.resume_session)
|
||
remove_session = W.QPushButton("删除选中保存会话")
|
||
remove_session.clicked.connect(self.remove_saved_session)
|
||
form.addRow("已保存的账号 / 区服 / 角色", self.saved_sessions)
|
||
saved_buttons = W.QHBoxLayout()
|
||
saved_buttons.addWidget(restore)
|
||
saved_buttons.addWidget(remove_session)
|
||
form.addRow(saved_buttons)
|
||
# Retain internal session controls for login/import code. They are never
|
||
# placed on the login page; normal account login fills these values.
|
||
self.session_fields = W.QWidget(self)
|
||
self.session_fields.hide()
|
||
self.server = W.QLineEdit()
|
||
self.token = W.QLineEdit()
|
||
self.token.setEchoMode(W.QLineEdit.EchoMode.Password)
|
||
self.key = W.QLineEdit(self.catalog.data["game_setting"].get("xyz1", DEFAULT_KEY))
|
||
self.key.setEchoMode(W.QLineEdit.EchoMode.Password)
|
||
self.reqid = spin(0, 2147483647, 0)
|
||
self.reqsid = spin(0, 2147483647, 0)
|
||
for widget in (self.server, self.token, self.key, self.reqid, self.reqsid):
|
||
widget.setParent(self.session_fields)
|
||
demo_button = W.QPushButton("退出登录")
|
||
demo_button.clicked.connect(self.demo)
|
||
clear_button = W.QPushButton("退出登录并清除登录记录")
|
||
clear_button.clicked.connect(self.logout_and_clear)
|
||
logout_row = W.QHBoxLayout()
|
||
logout_row.addWidget(demo_button)
|
||
logout_row.addWidget(clear_button)
|
||
logout_row.addStretch()
|
||
form.addRow(logout_row)
|
||
note = W.QLabel("账号密码和登录会话自动加密保存。登录后自动刷新状态,配置功能后开启顶部策略开关。")
|
||
note.setWordWrap(True)
|
||
form.addRow(note)
|
||
self.tabs.addTab(tab, "登录")
|
||
|
||
def policy_tab(self, embedded=False):
|
||
tab, form = W.QWidget(), W.QFormLayout()
|
||
tab.setLayout(form)
|
||
self.ranch_enabled = W.QCheckBox("启用培育室自动管理")
|
||
self.ranch_enabled.setChecked(True)
|
||
self.strategy = combo([("Wiki机会成本", "wiki"), ("金币优先:成熟后派遣", "gold"), ("经验优先:收取后喂养", "experience"), ("全部收取并保留", "keep")])
|
||
self.protect_star = spin(1, 6, 3)
|
||
self.protect_quality = combo([("S及以上", 4), ("A及以上", 3), ("B及以上", 2), ("全部资质", 1), ("不按资质保留", 5), ("四项全S(4S)才保留", 6)])
|
||
self.protect_quality.setToolTip("4S要求攻、防、生命、敏捷分别为S;锁定、队伍、保留星级等保护仍单独生效。")
|
||
self.protect_quality.setCurrentIndex(1)
|
||
self.keep_better_quality = W.QCheckBox("保留资质高于牧场同种培养代表的新魔物")
|
||
self.keep_better_quality.setToolTip("独立于S/A/B/C及4S条件:按四项成长范围归一化后的平均值比较,严格更高才算提升;牧场没有同种魔物时保留首只。")
|
||
self.room = combo([("自动选择有空位的牧场", 0)])
|
||
self.coin_exp = spin(0, 10000, 5, True)
|
||
self.reserved_types = W.QLineEdit()
|
||
self.reserve_eggs = W.QLineEdit()
|
||
self.fill = W.QCheckBox("自动填充空坑位")
|
||
self.fill.setChecked(True)
|
||
self.egg_order = combo([("短时间优先", "shortest"), ("金币/小时优先", "gold"), ("经验/小时优先", "experience"), ("长时间优先", "longest")])
|
||
self.min_gold = spin(0, 1000000, 0, True)
|
||
self.min_exp = spin(0, 1000000, 0, True)
|
||
rows = [("保留此星级及以上", self.protect_star), ("资质保留条件", self.protect_quality),
|
||
("收取到牧场", self.room),
|
||
("额外保留魔物编号(逗号分隔)", self.reserved_types),
|
||
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
|
||
for label, widget in rows:
|
||
form.addRow(label, widget)
|
||
form.addRow("同种资质提升保护", self.keep_better_quality)
|
||
for widget in (self.strategy, self.coin_exp, self.egg_order, self.min_gold, self.min_exp):
|
||
widget.setParent(self.session_fields)
|
||
form.addRow(W.QLabel("孵蛋开关、优先级和去向在“背包 → 魔物蛋”逐项配置。"))
|
||
self.target_status = W.QLabel("在“牧场”勾选喂养目标并设置优先级")
|
||
self.target_status.setWordWrap(True)
|
||
feed_page = W.QWidget()
|
||
self.feed_form = W.QFormLayout(feed_page)
|
||
self.feed_form.addRow("当前喂养状态", self.target_status)
|
||
feed_note = W.QLabel("喂养目标统一在“牧场”勾选并设置优先级,数字越小越先喂。达到当前突破等级上限后自动喂下一只;未勾选目标时不喂养。用于喂养的素材由魔物蛋规则指定。")
|
||
feed_note.setWordWrap(True)
|
||
self.feed_form.addRow(feed_note)
|
||
self.feed_form.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
|
||
self.feed_scroll = W.QScrollArea()
|
||
self.feed_scroll.setWidgetResizable(True)
|
||
self.feed_scroll.setFrameShape(W.QFrame.Shape.NoFrame)
|
||
self.feed_scroll.setWidget(feed_page)
|
||
form.addRow(W.QLabel("仅处理本次运行观察到的培育室魔物;已有牧场魔物不作为自动派遣/喂养素材。\n锁定、羁绊、已装备、队伍/探索中的魔物会保留。蛋的手机本地锁定无法从服务器读取,请设置保留蛋数量。"))
|
||
for label in tab.findChildren(W.QLabel):
|
||
label.setWordWrap(True)
|
||
form.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
|
||
scroll = W.QScrollArea()
|
||
scroll.setWidgetResizable(True)
|
||
scroll.setFrameShape(W.QFrame.Shape.NoFrame)
|
||
scroll.setWidget(tab)
|
||
self.policy_scroll = scroll
|
||
if embedded:
|
||
return scroll
|
||
self.tabs.addTab(scroll, "牧场策略")
|
||
|
||
def gifting_tab(self):
|
||
self.gift_page = W.QWidget()
|
||
layout = W.QVBoxLayout(self.gift_page)
|
||
self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,目标可手动或自动选择)")
|
||
self.gift_auto_representative = W.QCheckBox("每种魔物只培养一只,自动选择培养代表")
|
||
self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品")
|
||
self.gift_liked_only.setChecked(True)
|
||
self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。")
|
||
self.gift_status.setWordWrap(True)
|
||
for widget in (self.gift_enabled, self.gift_auto_representative, self.gift_liked_only, self.gift_status):
|
||
layout.addWidget(widget)
|
||
self.gift_clock = W.QLabel("策略已关闭")
|
||
layout.addWidget(self.gift_clock)
|
||
for widget in (self.gift_enabled, self.gift_auto_representative, self.gift_liked_only):
|
||
widget.toggled.connect(self.update_gift_status)
|
||
note = W.QLabel("自动模式按等级 → 好感 → 综合成长资质选择每种魔物的一只代表,全部相同时随机选定并记住;忽略手动勾选的重复目标。\n代表满好感或冷却时不改喂同种另一只,可继续处理其他种类。礼物开关和保留数量仍在“背包”设置。")
|
||
note.setWordWrap(True)
|
||
layout.addWidget(note)
|
||
self.gift_representatives = table(["魔物种类", "培养对象 ID", "等级", "好感 / 上限", "资质 攻/防/血/敏"])
|
||
self.gift_representatives.setMinimumHeight(120)
|
||
self.gift_representatives.setVisible(False)
|
||
layout.addWidget(self.gift_representatives, 1)
|
||
buttons = W.QHBoxLayout()
|
||
for label, callback in (("去背包选择物品", lambda: self.tabs.setCurrentWidget(self.inventory_tabs)),
|
||
("去牧场选择目标", lambda: self.tabs.setCurrentWidget(self.room_page)),
|
||
("刷新 / 预览培养对象", self.refresh)):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(callback)
|
||
buttons.addWidget(button)
|
||
layout.addLayout(buttons)
|
||
layout.addStretch()
|
||
self.tabs.addTab(self.gift_page, "自动赠礼")
|
||
|
||
def automation_tab(self):
|
||
self.automation_page = W.QWidget()
|
||
layout = W.QVBoxLayout(self.automation_page)
|
||
self.workflow_status = W.QLabel("策略已关闭;配置功能后开启顶部策略开关")
|
||
self.workflow_status.setWordWrap(True)
|
||
layout.addWidget(self.workflow_status)
|
||
self.workflow_next = W.QLabel("等待读取角色状态")
|
||
self.workflow_next.setWordWrap(True)
|
||
layout.addWidget(self.workflow_next)
|
||
preview = W.QPushButton("刷新 / 预览")
|
||
preview.clicked.connect(self.refresh)
|
||
layout.addWidget(preview)
|
||
settings = W.QWidget()
|
||
settings_layout = W.QVBoxLayout(settings)
|
||
settings_scroll = W.QScrollArea()
|
||
settings_scroll.setWidgetResizable(True)
|
||
settings_scroll.setFrameShape(W.QFrame.Shape.NoFrame)
|
||
settings_scroll.setWidget(settings)
|
||
layout.addWidget(settings_scroll, 1)
|
||
form = W.QFormLayout()
|
||
form.addRow(self.ranch_enabled)
|
||
self.buy_eggs = W.QCheckBox("自动从金币市场购蛋 / 抽蛋")
|
||
self.buy_ten = W.QCheckBox("优先十连(允许单抽时生效)")
|
||
self.buy_ten.setChecked(True)
|
||
self.allow_single_draw = W.QCheckBox("允许单抽(关闭时只进行十连)")
|
||
self.allow_single_draw.setToolTip("默认关闭。关闭时,补货缺口、可用金币或每日额度不足十连就等待,无蛋时也不会自动单抽;请将蛋规则的补货目标至少设为10。")
|
||
self.buy_ten.setEnabled(False)
|
||
self.allow_single_draw.toggled.connect(self.buy_ten.setEnabled)
|
||
self.dispatch = W.QCheckBox("成熟后按策略自动派遣")
|
||
self.collect = W.QCheckBox("保留或待喂养的魔物自动收取到牧场")
|
||
self.feed = W.QCheckBox("按策略喂养选定目标(受当前突破上限限制)")
|
||
self.feed_form.insertRow(0, self.feed)
|
||
for widget in (self.dispatch, self.collect, self.feed):
|
||
widget.setChecked(True)
|
||
self.market = combo([(f"{r['name']}市场 · {int(r['money'])} 金币/蛋", key) for key, r in self.catalog.data.get("markets", {}).items()])
|
||
self.egg_stock = spin(1, 1000, 12)
|
||
self.buy_batch = spin(1, 100, 5)
|
||
self.keep_money = spin(0, 1000000000, 1000)
|
||
self.daily_buy_money = spin(0, 1000000000, 5000)
|
||
self.hatch_max_star = combo([("1星", 1), ("1–2星", 2), ("1–3星", 3), ("1–4星", 4), ("1–5星", 5)])
|
||
self.hatch_max_star.setCurrentIndex(4)
|
||
self.egg_stock.setParent(self.session_fields)
|
||
self.hatch_max_star.setParent(self.session_fields)
|
||
for label, widget in (("买蛋", self.buy_eggs), ("新增规则默认市场", self.market),
|
||
("允许单抽", self.allow_single_draw), ("购买偏好", self.buy_ten), ("单抽时每批上限", self.buy_batch),
|
||
("至少保留金币", self.keep_money), ("每日购蛋金币额度(0=不购买)", self.daily_buy_money),
|
||
("孵蛋", self.fill), ("派遣", self.dispatch),
|
||
("收取", self.collect)):
|
||
form.addRow(label, widget)
|
||
settings_layout.addLayout(form)
|
||
self.market_status = W.QLabel()
|
||
self.market_status.setWordWrap(True)
|
||
settings_layout.addWidget(self.market_status)
|
||
self.workflow_rules = W.QLabel()
|
||
self.workflow_rules.setWordWrap(True)
|
||
settings_layout.addWidget(self.workflow_rules)
|
||
self.draw_status = W.QLabel("最近抽蛋:尚无记录")
|
||
self.draw_status.setWordWrap(True)
|
||
settings_layout.addWidget(self.draw_status)
|
||
note = W.QLabel("先在“背包魔物蛋”勾选并配置规则,再开始自动孵蛋。空坑按手动优先级独立随机1~2秒装填,不受整体刷新间隔影响。\n成熟后按各行选择派遣、喂养或保留;锁定、星级、资质和等级上限保护仍生效,只处理本次培育的魔物。")
|
||
note.setWordWrap(True)
|
||
settings_layout.addWidget(note)
|
||
settings_layout.addStretch()
|
||
preset = W.QPushButton("绿色史莱姆金币预设(仅孵此蛋)")
|
||
preset.clicked.connect(self.gold_preset)
|
||
preset.setToolTip("只勾选绿色史莱姆:优先级1、派遣、低于1时补至10,莉莉托斯市场;保留4星以上/A资质。应用后开启顶部策略开关。")
|
||
bottom = W.QHBoxLayout()
|
||
bottom.addWidget(preset)
|
||
layout.addLayout(bottom)
|
||
configure = W.QPushButton("去背包配置孵蛋规则")
|
||
configure.clicked.connect(lambda: self.tabs.setCurrentWidget(self.egg_page))
|
||
layout.addWidget(configure)
|
||
self.tabs.insertTab(1, self.automation_page, "自动孵蛋")
|
||
policy_tab = self.policy_page
|
||
self.automation_tabs = W.QTabWidget()
|
||
self.automation_tabs.addTab(settings_scroll, "孵蛋策略")
|
||
self.automation_tabs.addTab(policy_tab, "牧场策略")
|
||
self.automation_tabs.addTab(self.feed_scroll, "喂养策略")
|
||
layout.removeWidget(settings_scroll)
|
||
layout.insertWidget(2, self.automation_tabs, 1)
|
||
self.market.currentIndexChanged.connect(self.update_workflow_status)
|
||
self.daily_buy_money.valueChanged.connect(self.update_workflow_status)
|
||
for widget in (self.strategy, self.protect_quality, self.hatch_max_star):
|
||
widget.currentIndexChanged.connect(self.update_workflow_status)
|
||
self.fill.toggled.connect(self.arm_hatching)
|
||
self.ranch_enabled.toggled.connect(self.arm_hatching)
|
||
self.protect_star.valueChanged.connect(self.update_workflow_status)
|
||
self.keep_better_quality.toggled.connect(self.update_workflow_status)
|
||
self.update_workflow_status()
|
||
|
||
def strategy_changed(self, enabled):
|
||
if enabled:
|
||
self.start_workflow()
|
||
else:
|
||
self.stop_workflow()
|
||
|
||
def set_strategy_checked(self, enabled):
|
||
blocker = C.QSignalBlocker(self.strategy_toggle)
|
||
self.strategy_toggle.setChecked(enabled)
|
||
self.strategy_toggle.setText("停止" if enabled else "开启")
|
||
self.strategy_toggle.setToolTip("停止自动执行已勾选的功能;停止后继续自动刷新状态。" if enabled
|
||
else "开启后自动执行各页面已勾选的功能。")
|
||
del blocker
|
||
|
||
def start_workflow(self):
|
||
if self.closed or self.logout_phase is not None:
|
||
return
|
||
try:
|
||
policy = self.read_policy()
|
||
progression = self.read_progression_policy()
|
||
other = (self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked()
|
||
or policy.gift_enabled or progression.enabled)
|
||
if not (policy.enabled and any((policy.buy, policy.fill, policy.dispatch, policy.collect, policy.feed))) and not other:
|
||
self.report("请先勾选至少一项功能,并启用对应策略")
|
||
self.stop_workflow()
|
||
return
|
||
self.read_quest_policy()
|
||
if policy.enabled and not any(rule["enabled"] for rule in policy.egg_rules.values()) and not other:
|
||
self.report("请先在“背包魔物蛋”勾选要孵化的蛋,并设置优先级和孵出后的去向")
|
||
self.tabs.setCurrentWidget(self.egg_page)
|
||
self.stop_workflow()
|
||
return
|
||
except ValueError as error:
|
||
self.report("请先修正策略输入:" + str(error))
|
||
self.stop_workflow()
|
||
return
|
||
self.save_config(quiet=True)
|
||
self.monitoring = True
|
||
self.engine.heartbeat_enabled = True
|
||
self.set_strategy_checked(True)
|
||
self.next_poll = 0
|
||
if self.busy:
|
||
self.pending_execute = True
|
||
self.report("策略已开启,当前请求完成后运行勾选功能")
|
||
else:
|
||
self.refresh(automated=True)
|
||
self.update_workflow_status()
|
||
|
||
def stop_workflow(self):
|
||
self.set_strategy_checked(False)
|
||
self.engine.auto = False
|
||
self.cancel_progression()
|
||
self.pending_execute = False
|
||
self.next_gift = float("inf")
|
||
self.update_gift_clock()
|
||
self.arm_hatching()
|
||
self.update_workflow_status()
|
||
|
||
def gold_preset(self):
|
||
self.stop_workflow()
|
||
self.ranch_enabled.setChecked(True)
|
||
for widget in (self.buy_eggs, self.fill, self.dispatch, self.collect):
|
||
widget.setChecked(True)
|
||
self.buy_ten.setChecked(True)
|
||
self.allow_single_draw.setChecked(False)
|
||
self.feed.setChecked(False)
|
||
for widget, value in ((self.strategy, "gold"), (self.market, "sc_city1"), (self.egg_order, "shortest"), (self.protect_quality, 3), (self.hatch_max_star, 3)):
|
||
widget.setCurrentIndex(widget.findData(value))
|
||
self.protect_star.setValue(4)
|
||
for rule in self.egg_rules.values():
|
||
rule["enabled"] = False
|
||
self.egg_rules["1001010"] = {"enabled": True, "priority": 1, "action": "sell", "refill_below": 1, "refill_target": 10, "market_id": "sc_city1"}
|
||
self.render_egg_rules()
|
||
self.min_gold.setValue(0)
|
||
self.min_exp.setValue(0)
|
||
self.report("已应用绿色史莱姆规则:优先级1、孵出后派遣、低于1补至10;开启顶部策略开关后运行。")
|
||
self.refresh()
|
||
|
||
def update_target_status(self, *args):
|
||
if not hasattr(self, "target_status") or self.engine.snapshot is None:
|
||
return
|
||
try:
|
||
_, text = self.engine.planner.feed_status(self.engine.snapshot, self.read_policy())
|
||
self.target_status.setText(text)
|
||
except (ValueError, AttributeError):
|
||
pass
|
||
|
||
def update_workflow_status(self, *args):
|
||
if not hasattr(self, "workflow_status"):
|
||
return
|
||
active = self.strategy_toggle.isChecked() and self.monitoring
|
||
state = "策略已开启" if active else "策略已关闭"
|
||
state += " · 状态自动刷新" if self.monitoring else ""
|
||
self.workflow_status.setText(("演示 · " if self.engine.demo else "已登录 · ") + state)
|
||
if hasattr(self, "progression_enabled"):
|
||
enabled = [label for checked, label in ((self.ranch_enabled.isChecked(), "牧场 / 孵蛋"),
|
||
(self.gift_enabled.isChecked(), "赠礼"), (self.quest_enabled.isChecked(), "委托"),
|
||
(self.map_enabled.isChecked(), "扫荡"), (self.daily_enabled.isChecked(), "每日事务"),
|
||
(self.progression_enabled.isChecked(), "主线推进")) if checked]
|
||
self.workflow_status.setText(self.workflow_status.text() + ";已选功能:" + ("、".join(enabled) or "无"))
|
||
self.update_progression_status()
|
||
market = self.catalog.data.get("markets", {}).get(self.market.currentData(), {})
|
||
snapshot = self.engine.snapshot
|
||
if snapshot:
|
||
unlocked = snapshot.city_unlocked(market.get("city"))
|
||
left = self.engine.purchase_budget.remaining(snapshot.now, self.daily_buy_money.value())
|
||
self.market_status.setText(f"新增规则默认市场:{'已解锁' if unlocked else '未解锁'};今日购蛋额度剩余 {left} 金币(北京时间,按角色保存)。")
|
||
else:
|
||
self.market_status.setText("登录后显示市场解锁状态和购蛋剩余额度")
|
||
enabled = sum(bool(rule.get("enabled")) for rule in self.egg_rules.values())
|
||
self.workflow_rules.setText(f"手动孵蛋规则:已勾选 {enabled} 种;保留 {self.protect_star.value()} 星及以上;资质保护:{self.protect_quality.currentText()}。")
|
||
if self.keep_better_quality.isChecked():
|
||
self.workflow_rules.setText(self.workflow_rules.text() + " 额外保留优于同种培养代表的魔物。")
|
||
self.draw_status.setText("最近抽蛋:" + (self.engine.last_draw or "尚无记录"))
|
||
|
||
def render_egg_rules(self):
|
||
if self.engine.snapshot:
|
||
self.eggs.set_data(self.engine.snapshot, self.egg_rules, self.market.currentData() or "sc_city1")
|
||
|
||
def egg_rules_changed(self, rules, key):
|
||
previous = self.egg_rules.get(key, {})
|
||
self.egg_rules = rules
|
||
rule = rules[key]
|
||
if rule["enabled"] and (not previous.get("enabled") or previous.get("action") != rule["action"]):
|
||
if rule["action"] == "sell":
|
||
self.dispatch.setChecked(True)
|
||
elif rule["action"] == "feed":
|
||
self.feed.setChecked(True)
|
||
self.collect.setChecked(True)
|
||
else:
|
||
self.collect.setChecked(True)
|
||
self.settings_changed()
|
||
self.update_workflow_status()
|
||
self.statusBar().showMessage("孵蛋规则已更新,将自动保存并应用", 5000)
|
||
|
||
def filter_inventory(self, category, text):
|
||
self.inventory_tables[category].set_filter(text, category)
|
||
self.render_current_page()
|
||
|
||
def gift_items_changed(self, rules, key):
|
||
self.gift_items = rules
|
||
if rules[key]["enabled"]:
|
||
self.gift_enabled.setChecked(True)
|
||
self.settings_changed()
|
||
self.update_gift_status()
|
||
|
||
def update_gift_status(self, *args):
|
||
if not hasattr(self, "gift_status"):
|
||
return
|
||
targets = "自动选择每种魔物的唯一培养代表" if self.gift_auto_representative.isChecked() else f"已选择 {len(self.gift_targets)} 个手动目标"
|
||
self.gift_status.setText(f"已允许 {sum(bool(r.get('enabled')) for r in self.gift_items.values())} 种物品;{targets};每次赠礼一件,遵守当前好感上限和赠礼间隔。")
|
||
if hasattr(self, "gift_representatives"):
|
||
self.gift_representatives.setVisible(self.gift_auto_representative.isChecked())
|
||
|
||
def render_gift_representatives(self, snapshot):
|
||
if not self.gift_auto_representative.isChecked():
|
||
return
|
||
representatives = self.engine.cultivation.selected if self.engine.cultivation.owner == str(snapshot.raw["master"]["id"]) else {}
|
||
rows = [[self.catalog.monster(mon["typeId"]).get("name", mon["typeId"]), mon["id"], mon.get("level", 1),
|
||
f"{mon.get('feel') or 0} / {self.catalog.max_feel(mon)}", self.catalog.quality_text(mon)] for mon in representatives.values()]
|
||
fill_table(self.gift_representatives, rows)
|
||
|
||
def monster_view_changed(self, *args):
|
||
grouped = bool(self.monster_view.currentData())
|
||
self.monster_room.setEnabled(grouped)
|
||
self.ranch_view.set_view(grouped, self.monster_room.currentData() or 0)
|
||
if self.latest_render and self.presentation_active and self.tabs.currentWidget() is self.monster_page:
|
||
self.render_monsters(self.latest_render[0])
|
||
self.update_monster_actions()
|
||
|
||
def monster_feed_changed(self, mid, enabled, priority):
|
||
if enabled:
|
||
self.feed_targets[mid] = priority
|
||
self.feed.setChecked(True)
|
||
self.collect.setChecked(True)
|
||
else:
|
||
self.feed_targets.pop(mid, None)
|
||
self.settings_changed()
|
||
self.update_target_status()
|
||
|
||
def monster_gift_changed(self, mid, enabled, priority):
|
||
if enabled:
|
||
self.gift_targets[mid] = priority
|
||
self.gift_enabled.setChecked(True)
|
||
else:
|
||
self.gift_targets.pop(mid, None)
|
||
self.settings_changed()
|
||
self.update_gift_status()
|
||
|
||
def add_egg_rule(self):
|
||
choices = {f"{row.get('name', key)} [{key}]": key for key, row in self.catalog.monsters.items()
|
||
if not row.get("npc") and self.catalog.total_time(key) > 0}
|
||
name, accepted = W.QInputDialog.getItem(self, "添加魔物蛋规则", "选择魔物蛋(可输入名称筛选)", sorted(choices), 0, True)
|
||
if accepted and name in choices:
|
||
self.eggs.add_rule(choices[name])
|
||
|
||
def yield_tab(self):
|
||
tab, layout = W.QWidget(), W.QVBoxLayout()
|
||
tab.setLayout(layout)
|
||
note = W.QLabel(f"数值:本地 APK 1.9.68,共 {len(self.catalog.monsters)} 种;算法参考 <a href='{WIKI}'>Wiki 魔物收益表</a>。金币/小时为已有蛋的毛收益,不是购蛋净利润。")
|
||
note.setOpenExternalLinks(True)
|
||
layout.addWidget(note)
|
||
line = W.QHBoxLayout()
|
||
self.search = W.QLineEdit()
|
||
self.search.setPlaceholderText("按名称或编号筛选")
|
||
self.search.textChanged.connect(self.render_catalog)
|
||
line.addWidget(self.search)
|
||
self.yield_stars = {}
|
||
for star in range(1, 6):
|
||
check = W.QCheckBox(f"{star}星")
|
||
check.setChecked(True)
|
||
check.toggled.connect(self.render_catalog)
|
||
self.yield_stars[star] = check
|
||
line.addWidget(check)
|
||
button = W.QPushButton("导入自定义 CSV / XLSX")
|
||
button.clicked.connect(self.import_prices)
|
||
line.addWidget(button)
|
||
layout.addLayout(line)
|
||
self.yields = table(["魔物编号", "名称", "星", "培育时间", "派遣金币", "基础经验", "金币/小时", "经验/小时", "金币/经验", "建议(未计保留条件)"])
|
||
layout.addWidget(self.yields)
|
||
self.tabs.addTab(tab, "收益资料")
|
||
|
||
def quests_tab(self):
|
||
tab, layout = W.QWidget(), W.QVBoxLayout()
|
||
tab.setLayout(layout)
|
||
form = W.QFormLayout()
|
||
self.quest_enabled = W.QCheckBox("启用委托自动接取 / 推进 / 领奖")
|
||
self.quest_accept = W.QCheckBox("按氪金奖励优先接取(20 → 15 → 10)")
|
||
self.quest_accept.setChecked(True)
|
||
self.quest_city = spin(0, 99, 0)
|
||
self.quest_items = W.QCheckBox("允许提交道具(遵守保留数量)")
|
||
self.quest_monsters = W.QCheckBox("允许提交1级魔物(遵守锁定、星级和资质保留)")
|
||
self.quest_money = spin(0, 10000000, 0)
|
||
self.quest_battles = W.QCheckBox("也接取需要实战的委托")
|
||
self.quest_reserves = W.QLineEdit()
|
||
for label, widget in (("委托管理", self.quest_enabled), ("接取", self.quest_accept), ("城市编号(0=所有已解锁城市)", self.quest_city),
|
||
("道具提交", self.quest_items), ("魔物提交", self.quest_monsters), ("单次最多提交金币", self.quest_money),
|
||
("实战委托", self.quest_battles), ("保留道具(编号:数量,逗号分隔)", self.quest_reserves)):
|
||
form.addRow(label, widget)
|
||
layout.addLayout(form)
|
||
self.quest_summary = W.QLabel()
|
||
layout.addWidget(self.quest_summary)
|
||
note = W.QLabel("优先完成已接委托,按奖励氪金数量从高到低接取可完成的委托。缺少材料时优先从已支持的扫荡或挑战来源获取,遵守体力和物品保留设置。\n需要战斗的委托使用内置模拟计算,当前未支持的战斗会显示原因。按委托缺口自动购买并孵化魔物蛋的联动尚待实现。每日接取次数来自角色数据。")
|
||
note.setWordWrap(True)
|
||
layout.addWidget(note)
|
||
self.quests_table = table(["委托编号", "名称", "状态", "奖励金币", "奖励氪金", "需求 / 进度"])
|
||
layout.addWidget(self.quests_table)
|
||
self.tabs.addTab(tab, "自动委托")
|
||
|
||
def show_debug(self):
|
||
self.debug_window.show()
|
||
self.debug_window.raise_()
|
||
self.debug_window.activateWindow()
|
||
|
||
@C.Slot(object)
|
||
def on_network_event(self, event):
|
||
self.debug_window.add_event(event)
|
||
if event["operation"] in ("渠道账号验证", "获取官方区服", "进入选中区服", "读取角色", "本地区服整理"):
|
||
if event["kind"] == "request":
|
||
self.login_status.setText(event["operation"] + ":请求已发送…")
|
||
elif event["kind"] == "error":
|
||
self.login_status.setText(event["operation"] + ":失败,请查看调试窗口")
|
||
|
||
def save_login_info(self, *args, quiet=False):
|
||
try:
|
||
self.credentials.save(self.account.text().strip(), self.password.text(), self.remember_password.isChecked())
|
||
if not quiet:
|
||
self.report("已记住账号和密码" if self.remember_password.isChecked() else "已关闭记住功能并移除保存的登录信息")
|
||
except (OSError, ValueError):
|
||
self.report("登录信息未能保存,请检查本地状态目录和 Windows 账户")
|
||
|
||
def load_login_info(self):
|
||
try:
|
||
remember, account, password = self.credentials.load()
|
||
self.remember_password.setChecked(remember)
|
||
self.account.setText(account)
|
||
self.password.setText(password)
|
||
except (OSError, ValueError, KeyError, TypeError):
|
||
self.report("保存的登录信息无法读取,请在本机重新填写后保存")
|
||
|
||
def report(self, message):
|
||
for secret in (self.token.text(), self.key.text(), self.password.text()):
|
||
if secret:
|
||
message = message.replace(secret, "<隐藏>")
|
||
if "策略暂不可用" in message or "页面数据暂不可用" in message:
|
||
self.trace.emit("error", "本地策略 / 页面处理", scope="local", message=message)
|
||
self.log.appendPlainText(time.strftime("%H:%M:%S ") + battle_message(message, translate_unknown=False))
|
||
|
||
def remember_log_sizes(self, *args):
|
||
if self.show_log.isChecked():
|
||
self.log_sizes = self.log_splitter.sizes()
|
||
|
||
def toggle_log(self, visible):
|
||
if not visible and not self.log.isHidden():
|
||
self.log_sizes = self.log_splitter.sizes()
|
||
self.log.setVisible(visible)
|
||
self.show_log.setText("隐藏日志" if visible else "显示日志")
|
||
if visible:
|
||
self.log_splitter.setSizes(self.log_sizes)
|
||
|
||
def install_refresh_menus(self):
|
||
for index in range(self.tabs.count()):
|
||
tab = self.tabs.widget(index)
|
||
targets = [tab] + [widget.viewport() for widget in tab.findChildren(W.QAbstractItemView)] + [widget.viewport() for widget in tab.findChildren(W.QScrollArea)]
|
||
for target in targets:
|
||
target.setContextMenuPolicy(C.Qt.ContextMenuPolicy.CustomContextMenu)
|
||
target.customContextMenuRequested.connect(lambda position, target=target, tab=tab: self.page_menu(target, position, tab))
|
||
|
||
def page_menu(self, target, position, tab):
|
||
if getattr(self, "refresh_menu", None):
|
||
self.refresh_menu.close()
|
||
self.refresh_menu.deleteLater()
|
||
menu = W.QMenu(self)
|
||
self.refresh_menu = menu
|
||
action = menu.addAction("刷新本页")
|
||
action.triggered.connect(lambda: self.refresh_page(tab))
|
||
if tab is self.monster_page:
|
||
if target is self.monsters.viewport():
|
||
item = self.monsters.itemAt(position)
|
||
if item is not None and not item.isSelected():
|
||
self.monsters.clearSelection()
|
||
self.monsters.setCurrentItem(item)
|
||
item.setSelected(item.data(0, C.Qt.ItemDataRole.UserRole) is not None)
|
||
menu.addSeparator()
|
||
detail = menu.addAction("查看魔物详情")
|
||
detail.setEnabled(bool(self.selected_monster_ids()))
|
||
detail.triggered.connect(lambda: self.show_monster_detail(self.selected_monster_ids()[0]) if self.selected_monster_ids() else None)
|
||
for label, locked in (("锁定选中魔物", True), ("解锁选中魔物", False)):
|
||
action = menu.addAction(label)
|
||
action.setEnabled(bool(self.selected_monster_ids()) and not self.busy)
|
||
action.triggered.connect(lambda checked=False, locked=locked: self.change_monster_lock(locked))
|
||
for label, kind in (("派遣选中魔物…", "sell"), ("喂给指定魔物…", "feed")):
|
||
action = menu.addAction(label)
|
||
action.setEnabled(bool(self.selected_monster_ids()) and not self.busy)
|
||
action.triggered.connect(lambda checked=False, kind=kind: self.request_monster_action(kind))
|
||
menu.addSeparator()
|
||
for label, currency in (("新建牧场:使用金币…", "money"), ("新建牧场:使用氪金…", "ke")):
|
||
action = menu.addAction(label)
|
||
action.setEnabled(not self.busy)
|
||
action.triggered.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
|
||
elif tab in (self.slot_page, self.room_page):
|
||
if tab is self.slot_page and target is self.slots.viewport():
|
||
row = self.slots.indexAt(position).row()
|
||
if row >= 0:
|
||
self.slots.selectRow(row)
|
||
menu.addSeparator()
|
||
kind = "stack" if tab is self.slot_page else "room"
|
||
for label, currency in (("使用金币", "money"), ("使用氪金", "ke")):
|
||
action = menu.addAction(("开启选中普通坑位:" if kind == "stack" else "新建牧场:") + label + "…")
|
||
action.setEnabled(not self.busy)
|
||
action.triggered.connect(lambda checked=False, kind=kind, currency=currency: self.request_expansion(kind, currency))
|
||
menu.popup(target.mapToGlobal(position))
|
||
|
||
def selected_monster_ids(self):
|
||
return self.monsters.selected_monster_ids()
|
||
|
||
def show_monster_detail(self, mid):
|
||
if self.engine.snapshot is None:
|
||
return
|
||
mon = self.engine.snapshot.monsters.get(mid)
|
||
if not mon:
|
||
return
|
||
info = self.catalog.monster(mon["typeId"])
|
||
stats = self.catalog.reference_stats(mon)
|
||
growth = (" / ".join(str(mon.get("g" + stat.capitalize(), "?")) for stat in ("atk", "def", "hp", "dex"))
|
||
if all(q is not None for q in self.catalog.quality(mon)) else self.catalog.quality_text(mon))
|
||
text = (f"{mon.get('nicName') or info.get('name')} #{mid} {info.get('star', '?')}星\n"
|
||
f"等级:{mon.get('level', 1)} / {self.catalog.max_level(mon) or '?'};突破等级:{mon.get('potentialLevel', '?')}\n"
|
||
f"参考攻/防/生命/敏捷:{' / '.join(str(v) for v in stats)}\n"
|
||
f"成长资质:{self.catalog.quality_text(mon)}\n"
|
||
f"成长数值:{growth}\n"
|
||
f"好感:{mon.get('feel', '?')};潜能强化等级:{mon.get('tpLevel', '?')}\n"
|
||
f"喜欢:{self.catalog.likes_text(mon['typeId'])}\n\n"
|
||
"参考属性不含装备、羁绊或全局加成;双击条目可随时查看此详情。")
|
||
W.QMessageBox.information(self, "魔物详情", text)
|
||
|
||
def update_monster_actions(self):
|
||
ids = self.selected_monster_ids()
|
||
ready = bool(ids) and not self.busy and not self.closed
|
||
self.lock_monsters.setEnabled(ready)
|
||
self.unlock_monsters.setEnabled(ready)
|
||
self.monster_selection.setText(f"已选择 {len(ids)} 只;操作后关闭策略" if ids else "选择魔物后可锁定 / 解锁,也可右键操作")
|
||
|
||
def change_monster_lock(self, locked):
|
||
if self.busy or self.closed:
|
||
self.report("请等待当前请求完成后再修改锁定状态")
|
||
return
|
||
ids = self.selected_monster_ids()
|
||
if not ids:
|
||
self.report("请先在魔物表选择一只或多只魔物")
|
||
return
|
||
self.stop_workflow()
|
||
self.submit("monster_lock", lambda: self.engine.set_monster_lock(ids, locked))
|
||
|
||
def request_monster_action(self, kind):
|
||
if self.busy or self.closed or self.engine.snapshot is None:
|
||
self.report("请等待当前请求完成")
|
||
return
|
||
ids = self.selected_monster_ids()
|
||
snapshot, target_id = self.engine.snapshot, 0
|
||
self.stop_workflow()
|
||
if kind == "feed":
|
||
candidates = [m for m in snapshot.raw["monsters"] if int(m["id"]) not in ids and m.get("process") == 3
|
||
and self.catalog.max_level(m) is not None and int(m.get("level", 1)) < self.catalog.max_level(m)]
|
||
if not candidates:
|
||
self.report("没有可接收经验的牧场魔物,请检查当前突破上限")
|
||
return
|
||
choices = [f"{self.catalog.monster(m['typeId']).get('name')} Lv.{m.get('level', 1)}/{self.catalog.max_level(m)} #{m['id']}" for m in candidates]
|
||
choice, accepted = W.QInputDialog.getItem(self, "选择喂养目标", "将选中魔物作为经验素材,喂给:", choices, 0, False)
|
||
if not accepted:
|
||
return
|
||
target_id = int(candidates[choices.index(choice)]["id"])
|
||
try:
|
||
actions = manual_monster_actions(self.catalog, snapshot, kind, ids, target_id)
|
||
except ValueError as error:
|
||
self.report(str(error))
|
||
return
|
||
names = [f"{self.catalog.monster(snapshot.monsters[mid]['typeId']).get('name')} #{mid}" for mid in ids]
|
||
text = ";".join(a.description for a in actions) + "\n将消耗以下魔物,无法撤销:\n" + "\n".join(names[:15])
|
||
if len(names) > 15:
|
||
text += f"\n…共{len(names)}只"
|
||
self.stop_workflow()
|
||
if W.QMessageBox.question(self, "确认派遣" if kind == "sell" else "确认喂养", text,
|
||
W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No, W.QMessageBox.StandardButton.No) == W.QMessageBox.StandardButton.Yes:
|
||
self.submit("manual_monsters", lambda: self.engine.manage_monsters(kind, ids, target_id))
|
||
|
||
def request_expansion(self, kind, currency):
|
||
if self.busy or self.closed or self.engine.snapshot is None:
|
||
self.report("请等待当前请求完成")
|
||
return
|
||
position = -1
|
||
if kind == "stack":
|
||
selected = self.slots.selectionModel().selectedRows()
|
||
if selected:
|
||
position = int(self.slots.item(selected[0].row(), 0).text()) - 1
|
||
else:
|
||
opened = {int(s.get("position", -1)) for s in self.engine.snapshot.raw["stacks"]}
|
||
position = next((i for i in range(int(self.catalog.data["stack_meta"]["total"])) if i not in opened and i != 3), -1)
|
||
try:
|
||
quote = expansion_quote(self.catalog, self.engine.snapshot, kind, currency, position)
|
||
except ValueError as error:
|
||
self.report(str(error))
|
||
return
|
||
self.stop_workflow()
|
||
if W.QMessageBox.question(self, "确认开启坑位" if kind == "stack" else "确认新建牧场", quote.description + "\n确认消费并开通?",
|
||
W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No, W.QMessageBox.StandardButton.No) == W.QMessageBox.StandardButton.Yes:
|
||
self.submit("expansion", lambda: self.engine.expand(quote))
|
||
|
||
def refresh_page(self, tab=None):
|
||
tab = tab or self.tabs.currentWidget()
|
||
if self.busy:
|
||
self.pending_refresh = tab
|
||
self.statusBar().showMessage("当前请求完成后刷新本页")
|
||
return
|
||
if tab is self.yields.parentWidget():
|
||
self.render_catalog()
|
||
self.report("收益资料已从本地表刷新")
|
||
elif tab is self.map_page:
|
||
self.refresh_maps()
|
||
elif tab is self.analysis_page:
|
||
self.refresh_analysis()
|
||
elif tab is self.progression_page:
|
||
self.refresh_progression()
|
||
elif tab is self.battle_records_page:
|
||
self.refresh_progression_records()
|
||
else:
|
||
self.refresh()
|
||
|
||
def refresh_analysis(self):
|
||
if self.closed or self.engine.snapshot is None:
|
||
return
|
||
if self.busy:
|
||
self.pending_refresh = self.analysis_page
|
||
return
|
||
engine = self.engine
|
||
owner = engine.snapshot.raw["master"]["id"]
|
||
self.submit("analysis", lambda: engine.sweeper.statistics.snapshot(owner))
|
||
|
||
def reload_saved_sessions(self):
|
||
previous = self.saved_sessions.currentData()
|
||
self.saved_sessions.clear()
|
||
for entry in self.session_store.entries():
|
||
self.saved_sessions.addItem(entry["label"] + " / " + entry["saved_at"], entry["session_id"])
|
||
if self.saved_sessions.count():
|
||
self.saved_sessions.setCurrentIndex(max(0, self.saved_sessions.findData(previous)))
|
||
self.account.setReadOnly(True)
|
||
elif self.engine.demo:
|
||
self.account.setReadOnly(False)
|
||
|
||
def resume_session(self):
|
||
if self.busy:
|
||
self.report("请等待当前操作完成")
|
||
return
|
||
key = self.saved_sessions.currentData()
|
||
if not key:
|
||
self.report("此账号页签尚无保存会话,请先正常登录一次")
|
||
return
|
||
try:
|
||
session = self.session_store.load(key)
|
||
except (OSError, ValueError, TypeError, KeyError):
|
||
self.error("保存的会话无法读取,请重新登录")
|
||
return
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
self.session_label = self.saved_sessions.currentText().rsplit(" / ", 1)[0]
|
||
label = self.session_label
|
||
client = Client(session, trace=self.trace, on_session_change=lambda current: self.session_store.save(current, label))
|
||
self.login_status.setText("正在恢复会话并校验角色,策略保持关闭")
|
||
def restore():
|
||
try:
|
||
return client, client.snapshot()
|
||
except Exception:
|
||
client.close()
|
||
raise
|
||
self.submit("connected", restore)
|
||
|
||
def remove_saved_session(self):
|
||
key = self.saved_sessions.currentData()
|
||
if not key or self.busy:
|
||
return
|
||
if self.engine.client and isinstance(self.engine.client.session, Session) and identity(self.engine.client.session) == key:
|
||
self.report("请先退出登录,再删除当前正在使用的会话")
|
||
return
|
||
try:
|
||
self.session_store.remove(key)
|
||
self.reload_saved_sessions()
|
||
except (OSError, ValueError, KeyError):
|
||
self.report("保存的会话未能删除")
|
||
|
||
def use_role_workspace(self, session):
|
||
if not isinstance(session, Session) or not session.role_id:
|
||
return
|
||
key = identity(session)
|
||
if key == self.active_identity:
|
||
return
|
||
if self.active_identity:
|
||
self.save_config(quiet=True)
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
self.active_identity = key
|
||
self.state = self.profile_root / "roles" / key
|
||
self.load_config(copy.deepcopy(self.default_config))
|
||
self.load_config()
|
||
self.render_catalog()
|
||
|
||
def logout_and_clear(self):
|
||
if self.closed or self.logout_phase is not None:
|
||
return
|
||
engine = self.engine
|
||
resume_monitoring, resume_heartbeat = self.monitoring, engine.heartbeat_enabled
|
||
resume_timer = self.timer.isActive()
|
||
self.logout_phase = "confirming"
|
||
self.timer.stop()
|
||
self.monitoring = False
|
||
engine.heartbeat_enabled = False
|
||
self.stop_workflow()
|
||
self.pending_refresh = self.pending_policy = None
|
||
self.pending_preview = self.pending_monster_view = self.pending_progression_view = False
|
||
self.pending_schedule = False
|
||
text = "将退出登录,并删除当前账号页签保存的会话和账号密码。\n培养策略、日志及其他账号的记录不受影响。"
|
||
try:
|
||
confirmed = W.QMessageBox.question(self, "清除登录记录", text,
|
||
W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No,
|
||
W.QMessageBox.StandardButton.No) == W.QMessageBox.StandardButton.Yes
|
||
except Exception:
|
||
self.logout_phase = None
|
||
if resume_timer and not self.closed:
|
||
self.timer.start(500)
|
||
raise
|
||
if self.closed:
|
||
return
|
||
if not confirmed:
|
||
self.logout_phase = None
|
||
if self.engine is engine:
|
||
self.monitoring, engine.heartbeat_enabled = resume_monitoring, resume_heartbeat
|
||
if resume_timer:
|
||
self.timer.start(500)
|
||
return
|
||
self.logout_phase = "waiting"
|
||
self.statusBar().showMessage("正在退出登录;当前请求完成后清除登录记录" if self.busy else "正在退出登录")
|
||
if not self.busy:
|
||
self.finish_logout()
|
||
|
||
def finish_logout(self):
|
||
if self.busy or self.logout_phase != "waiting":
|
||
return
|
||
self.logout_phase = "finishing"
|
||
try:
|
||
self.pending_refresh = self.pending_policy = None
|
||
self.pending_execute = self.pending_preview = self.pending_schedule = False
|
||
self.pending_monster_view = self.pending_progression_view = False
|
||
self.demo()
|
||
if not self.engine.demo or self.engine.client is not None:
|
||
raise ValueError("原登录连接尚未释放")
|
||
keys = [entry["session_id"] for entry in self.session_store.entries()]
|
||
for key in keys:
|
||
self.session_store.remove(key)
|
||
self.credentials.save("", "", False)
|
||
self.account.clear()
|
||
self.password.clear()
|
||
self.account.setReadOnly(False)
|
||
self.password_login_result = None
|
||
self.reload_saved_sessions()
|
||
self.login_status.setText("已退出登录并清除当前账号页签的登录记录")
|
||
self.report("已清除当前账号页签的登录记录")
|
||
except (OSError, ValueError, KeyError, RuntimeError) as error:
|
||
self.report("退出登录或清除记录未完成:" + str(error) + ";策略保持停止")
|
||
finally:
|
||
self.logout_phase = None
|
||
self.monitoring = False
|
||
self.engine.auto = self.engine.heartbeat_enabled = False
|
||
if not self.closed:
|
||
self.timer.start(500)
|
||
if self.engine.demo:
|
||
self.refresh()
|
||
elif self.close_after_job:
|
||
C.QTimer.singleShot(0, self.close)
|
||
|
||
def run_job(self, kind, function):
|
||
"""All task requests share the account's existing serial worker."""
|
||
return self.submit(kind, function)
|
||
|
||
def update_policy(self, value=None):
|
||
"""Apply a whole policy set between requests, never during a worker call."""
|
||
if value is None:
|
||
value = self.config_value()
|
||
policies = {key: cls(**value[key]) for key, cls in (("policy", Policy), ("quest_policy", QuestPolicy),
|
||
("daily_policy", DailyPolicy), ("sweep_policy", SweepPolicy))}
|
||
policies["progression_policy"] = checked_progression_policy(value.get("progression_policy", {}))
|
||
if self.busy:
|
||
self.pending_policy = policies
|
||
return False
|
||
for key, policy in policies.items():
|
||
setattr(self.engine, key, policy)
|
||
return True
|
||
|
||
def submit(self, kind, function):
|
||
if self.busy or self.closed or self.logout_phase is not None:
|
||
return
|
||
self.busy = True
|
||
self.update_monster_actions()
|
||
catalog, engine = self.catalog, self.engine
|
||
self.sync_presentation_visibility()
|
||
progression_visible = self.presentation_active and self.tabs.currentWidget() is self.progression_page
|
||
records_visible = self.presentation_active and self.tabs.currentWidget() is self.battle_records_page
|
||
def background():
|
||
started = time.perf_counter()
|
||
value = function()
|
||
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "connected", "policy_preview", "progression_refresh", "progression_run"):
|
||
snapshot = value[1] if kind == "connected" else value[0]
|
||
managed = set() if kind == "connected" else set(engine.planner.managed)
|
||
preparing = time.perf_counter()
|
||
cache = engine.stage_cache
|
||
statistics = engine.sweeper.statistics
|
||
client = engine.client
|
||
if kind == "connected":
|
||
session = value[0].session
|
||
folder = self.profile_root / "roles" / identity(session) if isinstance(session, Session) and session.role_id else self.state
|
||
cache = StageCache(catalog, folder / "maps.json")
|
||
statistics = SweepStatistics(catalog, folder / "sweep_rewards.sqlite3")
|
||
client = value[0]
|
||
statistics.import_log(snapshot.raw["master"]["id"], getattr(getattr(client, "trace", None), "path", None))
|
||
views = prepare_views(catalog, snapshot, managed, cache, statistics,
|
||
include_monsters=self.presentation_active and not self.closed and (self.monster_view_visible or kind == "connected"))
|
||
explicit_progression = kind in ("progression_refresh", "progression_run")
|
||
if kind != "connected" and (progression_visible or records_visible or explicit_progression):
|
||
views.progression = prepare_progression_views(engine,
|
||
tasks=progression_visible or explicit_progression, records=records_visible or explicit_progression)
|
||
return Presented(value, views, (time.perf_counter() - preparing) * 1000, (time.perf_counter() - started) * 1000)
|
||
return value
|
||
job = Job(kind, background)
|
||
self.active_job = job
|
||
job.signals.result.connect(self.result, C.Qt.ConnectionType.QueuedConnection)
|
||
job.signals.error.connect(self.error, C.Qt.ConnectionType.QueuedConnection)
|
||
job.signals.done.connect(self.job_done, C.Qt.ConnectionType.QueuedConnection)
|
||
self.pool.start(job)
|
||
|
||
@C.Slot()
|
||
def job_done(self):
|
||
self.busy = False
|
||
self.update_monster_actions()
|
||
self.active_job = None
|
||
if self.logout_phase is not None:
|
||
if self.logout_phase == "waiting":
|
||
C.QTimer.singleShot(0, self.finish_logout)
|
||
elif self.close_after_job:
|
||
C.QTimer.singleShot(0, self.close)
|
||
return
|
||
if not self.presentation_active or self.tabs.currentWidget() not in (self.progression_page, self.battle_records_page):
|
||
self.pending_progression_view = False
|
||
if not self.monster_view_visible:
|
||
self.pending_monster_view = False
|
||
if self.pending_policy is not None and not self.closed:
|
||
policies, self.pending_policy = self.pending_policy, None
|
||
progression_changed = asdict(getattr(self.engine, "progression_policy", ProgressionPolicy())) != asdict(policies["progression_policy"])
|
||
for key, policy in policies.items():
|
||
setattr(self.engine, key, policy)
|
||
if progression_changed:
|
||
self.progression_views = None
|
||
if self.presentation_active and self.tabs.currentWidget() in (self.progression_page, self.battle_records_page):
|
||
self.pending_progression_view = True
|
||
if self.pending_schedule and not self.closed and not self.close_after_job:
|
||
self.pending_schedule = False
|
||
self.schedule()
|
||
if self.busy:
|
||
return
|
||
if self.close_after_job:
|
||
C.QTimer.singleShot(0, self.close)
|
||
elif self.pending_refresh is not None:
|
||
tab, self.pending_refresh = self.pending_refresh, None
|
||
C.QTimer.singleShot(0, lambda: self.refresh_page(tab))
|
||
elif self.pending_preview and not self.closed:
|
||
C.QTimer.singleShot(0, self.preview_cultivation)
|
||
elif self.pending_monster_view and not self.closed:
|
||
self.request_monster_views()
|
||
elif self.pending_progression_view and not self.closed:
|
||
C.QTimer.singleShot(0, lambda: self.request_progression_views(force=True))
|
||
elif self.pending_execute and self.monitoring and self.strategy_toggle.isChecked() and not self.closed:
|
||
self.pending_execute = False
|
||
C.QTimer.singleShot(0, lambda: self.refresh(automated=True))
|
||
|
||
@C.Slot(str, object)
|
||
def result(self, kind, value):
|
||
metrics = None
|
||
if isinstance(value, Presented):
|
||
self.prepared_views = value.views
|
||
if value.views.progression is not None:
|
||
self.accept_progression_views(value.views.progression)
|
||
metrics = value
|
||
value = value.value
|
||
started = time.perf_counter()
|
||
try:
|
||
self.apply_result(kind, value)
|
||
except (ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.error("显示数据时出错:" + str(error))
|
||
if metrics and not self.engine.demo:
|
||
self.trace.emit("info", "刷新耗时", scope="local", task=kind,
|
||
worker_total_ms=round(metrics.worker_ms, 1), data_prepare_ms=round(metrics.prepare_ms, 1),
|
||
ui_callback_ms=round((time.perf_counter() - started) * 1000, 1),
|
||
note="worker总耗时包含网络;大列表在后续短批次更新")
|
||
|
||
def apply_result(self, kind, value):
|
||
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "policy_preview", "progression_refresh", "progression_run"):
|
||
snapshot, plans, message = value
|
||
if kind != "policy_preview" and not self.engine.demo and not self.closed and self.logout_phase is None:
|
||
self.monitoring = True
|
||
self.engine.heartbeat_enabled = True
|
||
self.render(snapshot, plans)
|
||
self.report(message)
|
||
self.reload_saved_sessions()
|
||
if kind == "poll":
|
||
self.next_poll = time.monotonic() + self.poll_delay()
|
||
if "策略暂不可用" in message:
|
||
self.stop_workflow()
|
||
self.arm_hatching()
|
||
self.arm_gifting()
|
||
elif kind == "heartbeat":
|
||
self.report(value)
|
||
elif kind == "analysis":
|
||
if self.prepared_views:
|
||
self.prepared_views.drop_statistics = value
|
||
self.analysis_page.set_data(self.catalog, value)
|
||
self.report("已从本地刷新掉落统计")
|
||
elif kind == "progression_view":
|
||
self.accept_progression_views(value)
|
||
self.render_progression()
|
||
elif kind == "monster_view":
|
||
if value.snapshot is self.engine.snapshot:
|
||
self.prepared_views = value
|
||
self.render_current_page()
|
||
elif kind == "connected":
|
||
client, snapshot = value
|
||
if self.connection_guard and not self.connection_guard(client.session):
|
||
client.close()
|
||
self.report("该账号区服已在其他页签连接,请切换到对应页签")
|
||
return
|
||
client.trace = self.trace
|
||
self.use_role_workspace(client.session)
|
||
if self.engine.client and self.engine.client is not client:
|
||
self.engine.client.close()
|
||
self.engine = Engine(self.catalog, client, self.state / "purchase_budget.json")
|
||
self.sync_presentation_visibility()
|
||
self.clear_progression_views()
|
||
self.engine.snapshot = snapshot
|
||
if self.prepared_views and self.prepared_views.snapshot is snapshot and self.prepared_views.stage_cache:
|
||
self.engine.stage_cache = self.prepared_views.stage_cache
|
||
if self.prepared_views.statistics_store:
|
||
self.engine.sweeper.statistics = self.prepared_views.statistics_store
|
||
self.reset_map_view()
|
||
if isinstance(client.session, Session):
|
||
if client.session.account_name and client.session.account_name != self.account.text().strip():
|
||
_, saved_account, saved_password = self.credentials.load()
|
||
self.account.setText(client.session.account_name)
|
||
self.password.setText(saved_password if saved_account == client.session.account_name else "")
|
||
if not self.session_label:
|
||
self.session_label = f"{self.account.text().strip() or '导入账号'} / 区服 {client.session.server_id} / {snapshot.raw['master'].get('roleName', '')}"
|
||
label = self.session_label
|
||
client.on_session_change = lambda session: self.session_store.save(session, label)
|
||
client.persist_session()
|
||
self.reload_saved_sessions()
|
||
self.server.setText(client.session.server_url)
|
||
self.token.setText(client.session.token)
|
||
self.key.setText(client.session.key)
|
||
self.mode.setText("已登录")
|
||
self.login_status.setText("已进入所选区服并读取角色")
|
||
self.stop_workflow()
|
||
self.monitoring = not self.closed and self.logout_phase is None
|
||
if self.logout_phase is not None:
|
||
self.engine.heartbeat_enabled = False
|
||
self.next_poll = 0
|
||
self.account.setReadOnly(True)
|
||
self.render(snapshot, [])
|
||
try:
|
||
self.update_policy()
|
||
self.pending_preview = True
|
||
except (ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.report("状态已显示;策略暂不可用:" + str(error))
|
||
self.profile_changed.emit(self.session_label or snapshot.raw["master"].get("roleName", "已连接"))
|
||
self.tabs.setCurrentWidget(self.room_page)
|
||
self.report("已登录并开始自动刷新状态;配置功能后,点击顶部绿色“开启”即可运行")
|
||
elif kind == "sdk":
|
||
client, response, values = value
|
||
try:
|
||
servers = server_entries(response, values[4])
|
||
labels = [f"{s['id']} - {s['serverName']}" for s in servers]
|
||
except ApiError as error:
|
||
client.close()
|
||
self.error(str(error))
|
||
return
|
||
label, accepted = W.QInputDialog.getItem(self, "选择区服", "区服", labels, 0, False)
|
||
if accepted and label:
|
||
self.client_pending = (client, servers[labels.index(label)], values)
|
||
C.QTimer.singleShot(0, self.finish_sdk)
|
||
else:
|
||
client.close()
|
||
elif kind == "password":
|
||
client, response, context = value
|
||
self.password_login_result = None
|
||
self.server_list.clear()
|
||
self.enter_button.setEnabled(False)
|
||
try:
|
||
servers = server_entries(response)
|
||
response = response | {"servers": servers}
|
||
labels = server_labels(response)
|
||
except ApiError as error:
|
||
client.close()
|
||
self.error(str(error))
|
||
return
|
||
self.password_login_result = (client, response, context)
|
||
for label, server in zip(labels, servers):
|
||
self.server_list.addItem(label, server)
|
||
self.enter_button.setEnabled(self.server_list.count() > 0)
|
||
self.login_status.setText(f"已获取 {self.server_list.count()} 个官方区服,请选择后点击“进入选中区服”")
|
||
self.report(f"账号验证成功;官方返回 {self.server_list.count()} 个区服,请选择后进入")
|
||
|
||
@C.Slot(str)
|
||
def error(self, message):
|
||
self.pending_monster_view = False
|
||
self.monster_data_pending = False
|
||
self.monster_render_timer.stop()
|
||
last = self.trace.events[-1] if self.trace.events else {}
|
||
if last.get("kind") != "error" or last.get("message") != self.trace.redact(message):
|
||
self.trace.emit("error", "界面 / 任务处理", scope="local", message=message)
|
||
message = battle_message(message)
|
||
self.login_status.setText("操作失败,调试窗口中保留了请求和响应")
|
||
self.engine.auto = False
|
||
self.engine.heartbeat_enabled = False
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
self.report("已停止:" + message)
|
||
self.statusBar().showMessage(message)
|
||
|
||
def read_policy(self):
|
||
reserved = [int(v.strip()) for v in self.reserved_types.text().split(",") if v.strip()]
|
||
eggs = {}
|
||
for item in self.reserve_eggs.text().split(","):
|
||
if item.strip():
|
||
type_id, count = item.split(":")
|
||
eggs[str(int(type_id))] = max(0, int(count))
|
||
return Policy(enabled=self.ranch_enabled.isChecked(), strategy=self.strategy.currentData(), protect_star=self.protect_star.value(), protect_quality=self.protect_quality.currentData(),
|
||
feed_target=0, room_id=getattr(self, "restore_room", self.room.currentData() or 0),
|
||
coins_per_exp=self.coin_exp.value(), fill=self.fill.isChecked(), egg_order=self.egg_order.currentData(),
|
||
reserved_types=reserved, reserved_eggs=eggs, min_gold_per_hour=self.min_gold.value(), min_exp_per_hour=self.min_exp.value(),
|
||
collect=self.collect.isChecked(), dispatch=self.dispatch.isChecked(), feed=self.feed.isChecked(), hatch_max_star=self.hatch_max_star.currentData(),
|
||
buy=self.buy_eggs.isChecked(), market_id=self.market.currentData(), egg_stock=self.egg_stock.value(), buy_batch=self.buy_batch.value(),
|
||
buy_ten=self.buy_ten.isChecked(),
|
||
allow_single_draw=self.allow_single_draw.isChecked(),
|
||
manual_eggs=True, egg_rules=copy.deepcopy(self.egg_rules),
|
||
feed_targets=copy.deepcopy(self.feed_targets),
|
||
gift_enabled=self.gift_enabled.isChecked(), gift_targets=copy.deepcopy(self.gift_targets),
|
||
gift_items=copy.deepcopy(self.gift_items), gift_liked_only=self.gift_liked_only.isChecked(),
|
||
gift_auto_representative=self.gift_auto_representative.isChecked(), keep_better_quality=self.keep_better_quality.isChecked(),
|
||
keep_money=self.keep_money.value(), daily_buy_money=self.daily_buy_money.value())
|
||
|
||
def read_quest_policy(self):
|
||
reserves = {}
|
||
for item in self.quest_reserves.text().split(","):
|
||
if item.strip():
|
||
key, value = item.split(":")
|
||
reserves[str(int(key))] = max(0, int(value))
|
||
return QuestPolicy(enabled=self.quest_enabled.isChecked(), accept=self.quest_accept.isChecked(), city=self.quest_city.value(),
|
||
allow_items=self.quest_items.isChecked(), allow_monsters=self.quest_monsters.isChecked(), max_money=self.quest_money.value(),
|
||
battle_tasks=self.quest_battles.isChecked(), item_reserves=reserves)
|
||
|
||
def refresh(self, checked=False, *, automated=False, hatch_only=False):
|
||
if self.busy or self.closed or self.logout_phase is not None:
|
||
return
|
||
try:
|
||
self.update_policy()
|
||
self.engine.auto = self.strategy_toggle.isChecked() and automated and self.monitoring
|
||
if hatch_only:
|
||
self.hatch_timer.stop()
|
||
self.next_hatch = float("inf")
|
||
self.run_job("hatch" if hatch_only else "poll", lambda: self.engine.poll(hatch_only=hatch_only, defer_hatch=not hatch_only))
|
||
except ValueError as error:
|
||
self.stop_workflow()
|
||
self.engine.policy = Policy(enabled=False)
|
||
self.engine.quest_policy = QuestPolicy()
|
||
self.engine.progression_policy = ProgressionPolicy()
|
||
self.report("策略输入尚未完整,已关闭策略;本次继续刷新角色数据:" + str(error))
|
||
self.submit("poll", self.engine.poll)
|
||
|
||
def poll_delay(self):
|
||
return random.uniform(0, self.interval.currentData())
|
||
|
||
def poll_interval_changed(self, *args):
|
||
self.next_poll = time.monotonic() + self.poll_delay()
|
||
self.save_config(quiet=True)
|
||
|
||
def arm_hatching(self):
|
||
if (self.engine.pending_hatches and self.monitoring and self.strategy_toggle.isChecked()
|
||
and self.ranch_enabled.isChecked() and self.fill.isChecked() and not self.closed):
|
||
if self.next_hatch < float("inf"):
|
||
if not self.hatch_timer.isActive():
|
||
self.hatch_timer.start(max(0, round((self.next_hatch - time.monotonic()) * 1000)))
|
||
return
|
||
delay = random.uniform(1, 2)
|
||
self.next_hatch = time.monotonic() + delay
|
||
self.hatch_timer.start(round(delay * 1000))
|
||
else:
|
||
self.hatch_timer.stop()
|
||
self.next_hatch = float("inf")
|
||
|
||
def arm_gifting(self):
|
||
ready_at = self.engine.gift_planner.next_ready_at
|
||
if (self.monitoring and self.strategy_toggle.isChecked() and self.gift_enabled.isChecked()
|
||
and not self.closed and self.engine.snapshot is not None and ready_at is not None):
|
||
self.next_gift = time.monotonic() + max(0, ready_at - self.engine.snapshot.now)
|
||
else:
|
||
self.next_gift = float("inf")
|
||
self.update_gift_clock()
|
||
|
||
def update_gift_clock(self):
|
||
if not hasattr(self, "gift_clock"):
|
||
return
|
||
if not self.strategy_toggle.isChecked():
|
||
text = "策略已关闭"
|
||
elif not self.gift_enabled.isChecked():
|
||
text = "自动赠礼未启用"
|
||
elif self.next_gift == float("inf"):
|
||
text = "当前没有符合条件的赠礼目标或物品,等待状态更新"
|
||
else:
|
||
remaining = self.next_gift - time.monotonic()
|
||
text = "已有可赠礼目标,正在顺序处理" if remaining <= 0 else "下次可赠礼倒计时:" + duration(remaining)
|
||
if self.gift_clock.text() != text:
|
||
self.gift_clock.setText(text)
|
||
|
||
def schedule(self):
|
||
self.update_gift_clock()
|
||
if self.closed or self.logout_phase is not None:
|
||
return
|
||
if self.busy:
|
||
if self.active_job and self.active_job.kind == "monster_view":
|
||
self.pending_schedule = True
|
||
return
|
||
now = time.monotonic()
|
||
if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240:
|
||
self.submit("heartbeat", self.engine.keep_alive)
|
||
elif not self.engine.demo and self.monitoring and self.engine.pending_recovery_due():
|
||
self.refresh(automated=True)
|
||
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.master_sync_due():
|
||
self.submit("master_sync", self.engine.sync_master)
|
||
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due():
|
||
self.submit("growth_sync", self.engine.sync_growth)
|
||
elif (self.monitoring and self.strategy_toggle.isChecked() and self.fill.isChecked()
|
||
and self.ranch_enabled.isChecked() and now >= self.next_hatch):
|
||
self.refresh(automated=True, hatch_only=True)
|
||
elif self.monitoring and now >= self.next_poll:
|
||
self.refresh(automated=True)
|
||
elif self.monitoring and self.strategy_toggle.isChecked() and now >= self.next_gift:
|
||
self.refresh(automated=True)
|
||
|
||
def render(self, snapshot, plans):
|
||
self.latest_render = (snapshot, plans)
|
||
self.engine.snapshot = snapshot
|
||
self.refresh_progression_teams(snapshot)
|
||
master = snapshot.raw["master"]
|
||
self.summary.setText(f"{master.get('roleName', '')} | Lv.{master.get('level', '?')} | 经验 {self.catalog.master_experience(master)} | 金币 {master.get('money', '?')} | 氪金 {master.get('ke', '?')} | 体力 {master.get('ti', '?')}")
|
||
decisions = {int((a.payload.get('monsterId') or a.payload.get('monsterIds') or a.payload.get('foods') or [0])[0]): a.description for a in plans if a.kind in ('sell', 'feed')}
|
||
rows = []
|
||
opened = {int(s.get("position", -1)): s for s in snapshot.raw["stacks"]}
|
||
total_slots = max(int(self.catalog.data.get("stack_meta", {}).get("total", 0)), max(opened, default=-1) + 1)
|
||
vip = float((snapshot.raw.get("activityHistory", {}).get("vipInfo") or {}).get("vipTime") or 0)
|
||
vip = (vip / 1000 if vip > 100_000_000_000 else vip) > snapshot.now
|
||
for position in range(total_slots):
|
||
slot = opened.get(position)
|
||
if slot is None:
|
||
rows.append([position + 1, "", "VIP专用" if position == 3 else "未开启", "", "", "", "", "", ""])
|
||
continue
|
||
status = ("VIP已激活" if vip else "VIP未激活") if position == 3 else "已开启"
|
||
mon = snapshot.monsters.get(int(slot.get("monsterId") or 0))
|
||
if mon:
|
||
row = self.catalog.monster(mon.get("typeId"))
|
||
phase = snapshot.phase_text(mon, self.catalog)
|
||
rows.append([position + 1, slot["id"], status, row.get("name", "未知"), row.get("star", "?"), phase,
|
||
duration(snapshot.remaining(mon, self.catalog)), self.catalog.quality_text(mon),
|
||
decisions.get(int(mon["id"]), self.engine.planner.statuses.get(int(mon["id"]), "等待成长 / 预览规则"))])
|
||
else:
|
||
rows.append([position + 1, slot["id"], status, "空位", "", "", "", "", ""])
|
||
fill_table(self.slots, rows)
|
||
self.slot_status.setText(f"已开启 {len(opened)} / {total_slots} 个坑位;第4坑为VIP专用({'已激活' if vip else '未激活'})。选择“未开启”的普通坑位后可扩建。")
|
||
eggs = snapshot.eggs(self.catalog)
|
||
incubating = sum(int(slot.get("monsterId") or 0) > 0 for slot in snapshot.raw["stacks"])
|
||
stamp = time.strftime("%H:%M:%S", time.localtime(snapshot.received_at))
|
||
self.data_summary.setText(f"培育坑位 {len(snapshot.raw['stacks'])}(使用 {incubating}) | 魔物蛋 {len(eggs)} 类 / {sum(int(egg.get('num') or 0) for egg in eggs)} 枚 | 物品 {sum(int(i.get('num') or 0) > 0 for i in snapshot.raw['items'])} 类 | 魔物 {len(snapshot.raw['monsters'])} | 牧场 {len(snapshot.raw['rooms'])} | 更新 {stamp}")
|
||
fill_table(self.plans, [[a.kind, a.description] for a in plans])
|
||
self.workflow_next.setText("下一步:" + plans[0].description if plans else "当前等待:" + ";".join(list(dict.fromkeys(self.engine.planner.notes))[:4]) if self.engine.planner.notes else "点击刷新 / 预览查看下一步")
|
||
self.update_workflow_status()
|
||
left = snapshot.raw.get("history", {}).get("loopTaskNum", "未知")
|
||
self.quest_summary.setText(f"今日剩余可接次数:{left};当前委托:{len(self.engine.tasks.current(snapshot))}")
|
||
if not self.engine.demo:
|
||
self.reqid.setValue(self.engine.client.session.reqid)
|
||
self.reqsid.setValue(self.engine.client.session.reqsid)
|
||
|
||
if self.presentation_active:
|
||
self.render_current_page()
|
||
|
||
def sync_presentation_visibility(self):
|
||
page = self.tabs.currentWidget()
|
||
self.engine.presentation_active = bool(self.presentation_active)
|
||
self.engine.progression_view_active = bool(self.presentation_active and page is self.progression_page)
|
||
self.monster_view_visible = bool(self.presentation_active and page is self.monster_page)
|
||
|
||
def set_presentation_active(self, active):
|
||
self.presentation_active = bool(active)
|
||
self.sync_presentation_visibility()
|
||
if not active:
|
||
self.pending_monster_view = False
|
||
if self.prepared_views:
|
||
self.prepared_views.monsters = self.prepared_views.monster_source = None
|
||
self.pending_progression_view = False
|
||
self.analysis_page.row_batch.stop()
|
||
self.progression_table.row_batch.stop()
|
||
self.battle_records_table.row_batch.stop()
|
||
for name in ("map_render_timer", "monster_render_timer"):
|
||
timer = getattr(self, name, None)
|
||
if timer:
|
||
timer.stop()
|
||
if hasattr(self.eggs, "row_batch"):
|
||
self.eggs.row_batch.stop()
|
||
for inventory in self.inventory_tables.values():
|
||
inventory.row_batch.stop()
|
||
elif self.latest_render:
|
||
self.render_current_page()
|
||
|
||
def render_current_page(self, *args):
|
||
self.sync_presentation_visibility()
|
||
if self.closed or not self.presentation_active or not self.latest_render:
|
||
return
|
||
snapshot, plans = self.latest_render
|
||
page = self.tabs.currentWidget()
|
||
if page not in (self.progression_page, self.battle_records_page):
|
||
self.pending_progression_view = False
|
||
if page is not self.monster_page:
|
||
self.pending_monster_view = False
|
||
for target, widget in ((self.progression_page, self.progression_table),
|
||
(self.battle_records_page, self.battle_records_table)):
|
||
if page is not target:
|
||
widget.row_batch.stop()
|
||
if page is not self.analysis_page:
|
||
self.analysis_page.row_batch.stop()
|
||
for name, target in (("map_render_timer", self.map_page), ("monster_render_timer", self.monster_page)):
|
||
timer = getattr(self, name, None)
|
||
if timer and page is not target:
|
||
timer.stop()
|
||
inventory_page = self.inventory_tabs.currentWidget() if page is self.inventory_tabs else None
|
||
active_inventory = self.inventory_tables.get(inventory_page.property("inventory_category")) if inventory_page else None
|
||
if inventory_page is not self.egg_rules_page and hasattr(self.eggs, "row_batch"):
|
||
self.eggs.row_batch.stop()
|
||
for inventory in self.inventory_tables.values():
|
||
if inventory is not active_inventory:
|
||
inventory.row_batch.stop()
|
||
try:
|
||
if page is self.monster_page:
|
||
self.render_monsters(snapshot)
|
||
elif page is self.inventory_tabs:
|
||
if self.inventory_tabs.currentWidget() is self.egg_rules_page:
|
||
self.render_egg_rules()
|
||
elif active_inventory is not None:
|
||
active_inventory.set_data(snapshot, self.gift_items)
|
||
elif page is self.egg_page:
|
||
self.render_egg_rules()
|
||
elif page is self.quests_table.parentWidget():
|
||
self.render_quests(snapshot)
|
||
elif page is self.map_page:
|
||
self.render_maps()
|
||
elif page is self.analysis_page:
|
||
views = self.prepared_views
|
||
owner = str(snapshot.raw["master"]["id"])
|
||
if views and views.snapshot is snapshot and views.drop_statistics is not None and views.drop_statistics.get("owner") == owner:
|
||
data = views.drop_statistics
|
||
elif self.analysis_page.data.get("owner") == owner:
|
||
data = self.analysis_page.data
|
||
else:
|
||
data = {"owner": owner, "totals": {}, "drops": {}}
|
||
self.analysis_page.set_data(self.catalog, data)
|
||
elif page is self.daily_page:
|
||
self.render_daily()
|
||
elif page is self.gift_page:
|
||
self.render_gift_representatives(snapshot)
|
||
elif page in (self.progression_page, self.battle_records_page):
|
||
self.render_progression()
|
||
elif page is self.automation_page:
|
||
self.refresh_target_choices(snapshot)
|
||
except (ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.report("页面数据暂不可用:" + str(error))
|
||
|
||
def render_monsters(self, snapshot):
|
||
views = self.prepared_views
|
||
managed = self.engine.planner.managed
|
||
if views and views.snapshot is snapshot and views.monsters is not None and views.managed == managed:
|
||
self.pending_monster_view = False
|
||
if self.monster_data_pending:
|
||
self.monster_render_timer.stop()
|
||
self.monster_data_pending = False
|
||
self.monsters.set_data(snapshot, views.monsters, self.feed_targets, self.gift_targets)
|
||
else:
|
||
self.request_monster_views(snapshot)
|
||
|
||
def request_monster_views(self, snapshot=None):
|
||
if self.closed or self.logout_phase is not None or not self.monster_view_visible:
|
||
return
|
||
# Rendering is still pending while the serial worker prepares its data.
|
||
self.monster_render_timer.stop()
|
||
self.monster_render_timer.running = True
|
||
self.monster_data_pending = True
|
||
if self.busy:
|
||
self.pending_monster_view = True
|
||
return
|
||
snapshot = snapshot or self.engine.snapshot
|
||
if snapshot is None:
|
||
self.monster_render_timer.stop()
|
||
self.monster_data_pending = False
|
||
return
|
||
self.pending_monster_view = False
|
||
engine, catalog = self.engine, self.catalog
|
||
self.run_job("monster_view", lambda: prepare_views(catalog, snapshot, engine.planner.managed,
|
||
engine.stage_cache, engine.sweeper.statistics,
|
||
include_monsters=self.monster_view_visible and self.presentation_active and not self.closed))
|
||
|
||
def refresh_target_choices(self, snapshot):
|
||
self.update_combo(self.room, [("自动选择有空位的牧场", 0)] + [(f"牧场 {r['id']}", int(r["id"])) for r in snapshot.raw["rooms"]])
|
||
if hasattr(self, "restore_room"):
|
||
self.room.setCurrentIndex(max(0, self.room.findData(self.restore_room)))
|
||
del self.restore_room
|
||
self.update_target_status()
|
||
self.update_combo(self.monster_room, [("全部牧场", 0)] + [(f"{r.get('name') or '牧场'} #{r['id']}", int(r["id"])) for r in snapshot.raw["rooms"]])
|
||
self.update_gift_status()
|
||
|
||
def render_quests(self, snapshot):
|
||
quest_policy = self.read_quest_policy()
|
||
quest_rows = self.engine.tasks.rows(snapshot, quest_policy, self.read_policy())
|
||
diagnostics = {str(row.get("task_type_id")): row for row in self.engine.progression_rows()
|
||
if row.get("category") == "commission"}
|
||
rows = []
|
||
for key, name, status, text, meta in quest_rows:
|
||
diagnostic = diagnostics.get(str(key), {})
|
||
reason = diagnostic.get("block_reason") or diagnostic.get("blocked_reason")
|
||
if reason:
|
||
status = "暂不接取" if "city" in meta else "等待条件"
|
||
text = reason
|
||
elif diagnostic.get("next_action"):
|
||
text = diagnostic["next_action"]
|
||
reward = self.catalog.data["task_info"][key].get("reward", {})
|
||
rows.append([key, name, status, reward.get("money", 0), reward.get("ke", 0), battle_message(text)])
|
||
fill_table(self.quests_table, rows)
|
||
|
||
@staticmethod
|
||
def update_combo(widget, rows):
|
||
if [(widget.itemText(i), widget.itemData(i)) for i in range(widget.count())] == rows:
|
||
return
|
||
previous = widget.currentData()
|
||
blocker = C.QSignalBlocker(widget)
|
||
widget.clear()
|
||
for text, data in rows:
|
||
widget.addItem(text, data)
|
||
widget.setCurrentIndex(max(0, widget.findData(previous)))
|
||
|
||
def render_catalog(self):
|
||
if not hasattr(self, "yields"):
|
||
return
|
||
query = self.search.text().strip().lower()
|
||
rows = []
|
||
threshold = self.coin_exp.value() if hasattr(self, "coin_exp") else 5
|
||
for type_id in self.catalog.monsters:
|
||
row = self.catalog.monster(type_id)
|
||
if int(row.get("star", 0)) not in {star for star, check in self.yield_stars.items() if check.isChecked()}:
|
||
continue
|
||
if query and query not in str(type_id) and query not in row.get("name", "").lower():
|
||
continue
|
||
total = self.catalog.total_time(type_id)
|
||
if not total:
|
||
continue
|
||
money, exp = row.get("sell_money", 0), row.get("sell_exp", 0)
|
||
ratio = money / exp if exp else float("inf")
|
||
rows.append([int(type_id), row.get("name"), row.get("star"), duration(total), money, exp, round(money * 3600 / total, 2),
|
||
round(exp * 3600 / total, 2), round(ratio, 3) if exp else "无经验", "适合喂养" if ratio < threshold else "适合派遣"])
|
||
fill_table(self.yields, rows)
|
||
|
||
def import_prices(self):
|
||
path, _ = W.QFileDialog.getOpenFileName(self, "导入价格", "", "数据 (*.csv *.xlsx)")
|
||
if path:
|
||
try:
|
||
count = self.catalog.import_prices(path)
|
||
self.render_catalog()
|
||
self.report(f"已导入 {count} 项自定义数值")
|
||
except Exception:
|
||
self.error("导入失败:需要 typeId/编号、sell_money/派遣金币、sell_exp/强化经验列")
|
||
|
||
def import_session(self):
|
||
path, _ = W.QFileDialog.getOpenFileName(self, "导入本地会话", "", "会话 (*.json *.har)")
|
||
if path:
|
||
try:
|
||
session = Session.imported(json.loads(Path(path).read_text(encoding="utf-8-sig")), self.key.text())
|
||
self.server.setText(session.server_url)
|
||
self.token.setText(session.token)
|
||
self.key.setText(session.key)
|
||
self.reqid.setValue(session.reqid)
|
||
self.reqsid.setValue(session.reqsid)
|
||
self.report("已读取会话,尚未连接;原文件不会复制到设置目录")
|
||
except Exception:
|
||
self.error("会话导入失败,请检查 JSON/HAR 内容及协议密钥")
|
||
|
||
def connect_session(self):
|
||
if self.busy:
|
||
return
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
self.session_label = ""
|
||
if not self.token.text().strip():
|
||
self.error("请先导入手机会话或填写 Token")
|
||
return
|
||
client = Client(Session(self.server.text(), self.token.text().strip(), self.key.text(), self.reqid.value(), self.reqsid.value()), trace=self.trace)
|
||
self.submit("connected", lambda: (client, client.snapshot()))
|
||
|
||
def demo(self):
|
||
if self.busy or self.logout_phase not in (None, "finishing"):
|
||
return
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
if self.active_identity:
|
||
self.save_config(quiet=True)
|
||
if self.engine.client:
|
||
self.engine.client.persist_session()
|
||
self.engine.client.close()
|
||
self.engine = Engine(self.catalog)
|
||
self.sync_presentation_visibility()
|
||
self.clear_progression_views()
|
||
self.reset_map_view()
|
||
self.analysis_page.set_data(self.catalog, {"owner": "", "totals": {}, "drops": {}})
|
||
self.active_identity = None
|
||
self.state = self.profile_root
|
||
self.load_config(copy.deepcopy(self.default_config))
|
||
self.load_config()
|
||
self.session_label = ""
|
||
self.account.setReadOnly(self.saved_sessions.count() > 0)
|
||
self.mode.setText("未登录")
|
||
self.refresh()
|
||
|
||
def sdk_login(self):
|
||
if self.busy:
|
||
return
|
||
dialog = W.QDialog(self)
|
||
dialog.setWindowTitle("渠道 SDK 会话登录")
|
||
form = W.QFormLayout(dialog)
|
||
fields = {name: W.QLineEdit(value) for name, value in (("登录中心", self.catalog.data['server_info']['ANDROID']['DYD']), ("SDK用户ID", ""), ("SDK Token", ""), ("渠道", "DYD"), ("平台", "ANDROID"), ("设备ID", "pc"))}
|
||
fields["SDK Token"].setEchoMode(W.QLineEdit.EchoMode.Password)
|
||
for label, widget in fields.items():
|
||
form.addRow(label, widget)
|
||
buttons = W.QDialogButtonBox(W.QDialogButtonBox.StandardButton.Ok | W.QDialogButtonBox.StandardButton.Cancel)
|
||
buttons.accepted.connect(dialog.accept)
|
||
buttons.rejected.connect(dialog.reject)
|
||
form.addRow(buttons)
|
||
if dialog.exec() != W.QDialog.DialogCode.Accepted:
|
||
return
|
||
values = [fields[name].text().strip() for name in fields]
|
||
if not all(values[:3]):
|
||
self.error("需要登录中心、SDK用户ID和SDK Token")
|
||
return
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
client = Client(Session(key=self.key.text()), trace=self.trace)
|
||
self.submit("sdk", lambda: (client, client.sdk_login(values[0], values[1], values[2], values[3], values[4], values[5],
|
||
tj_channel=self.catalog.data.get("tjchannel", {}).get("tjchannel", "unknow")), values))
|
||
|
||
def password_login(self):
|
||
if self.busy:
|
||
return
|
||
account, password = self.account.text(), self.password.text()
|
||
if not account.strip() or not password:
|
||
self.report("请先填写账号和密码")
|
||
return
|
||
if self.login_guard and not self.login_guard(account.strip()):
|
||
self.report("该账号已在另一个页签连接,请切换到该页签")
|
||
return
|
||
self.save_login_info(quiet=True)
|
||
self.monitoring = False
|
||
self.stop_workflow()
|
||
self.enter_button.setEnabled(False)
|
||
self.server_list.clear()
|
||
if self.password_login_result and self.password_login_result[0] is not self.engine.client:
|
||
self.password_login_result[0].close()
|
||
self.password_login_result = None
|
||
self.login_status.setText("正在验证渠道账号;成功后获取官方区服")
|
||
flow = PasswordLogin(self.catalog, device_id(self.profile_root), trace=self.trace)
|
||
self.submit("password", lambda: flow.authenticate(account, password))
|
||
|
||
def enter_password_server(self):
|
||
if self.busy or self.password_login_result is None or self.server_list.currentData() is None:
|
||
return
|
||
client, _, context = self.password_login_result
|
||
server = self.server_list.currentData()
|
||
self.session_label = ""
|
||
self.trace.emit("info", "选择区服", server_id=server["id"], server_name=server["serverName"], game_server=server.get("gameServerAddress"))
|
||
def enter():
|
||
client.enter_server(context["center_url"], server, context["uid"], self.catalog,
|
||
context["channel"], "ANDROID", context["device_id"])
|
||
return client, client.snapshot()
|
||
self.submit("connected", enter)
|
||
|
||
def finish_sdk(self):
|
||
if self.busy:
|
||
C.QTimer.singleShot(100, self.finish_sdk)
|
||
return
|
||
client, server, values = self.client_pending
|
||
self.session_label = ""
|
||
def enter():
|
||
client.enter_server(values[0], server, values[1], self.catalog, values[3], values[4], values[5])
|
||
return client, client.snapshot()
|
||
self.submit("connected", enter)
|
||
|
||
def config_value(self):
|
||
return {"policy": asdict(self.read_policy()), "quest_policy": asdict(self.read_quest_policy()),
|
||
"daily_policy": asdict(self.read_daily_policy()), "sweep_policy": asdict(self.read_sweep_policy()),
|
||
"progression_policy": asdict(self.read_progression_policy()),
|
||
"overrides": copy.deepcopy(self.catalog.overrides),
|
||
"log_visible": self.show_log.isChecked(), "log_sizes": self.log_splitter.sizes() if self.show_log.isChecked() else self.log_sizes,
|
||
"yield_stars": [star for star, check in self.yield_stars.items() if check.isChecked()],
|
||
"interval": self.interval.currentData()}
|
||
|
||
def setup_autosave(self):
|
||
self.auto_save_timer = C.QTimer(self)
|
||
self.auto_save_timer.setSingleShot(True)
|
||
self.auto_save_timer.timeout.connect(self.persist_settings)
|
||
names = ("ranch_enabled", "strategy", "protect_star", "protect_quality", "room",
|
||
"coin_exp", "reserved_types", "reserve_eggs", "fill", "egg_order", "min_gold", "min_exp", "buy_eggs",
|
||
"buy_ten", "allow_single_draw", "dispatch", "collect", "feed", "market", "egg_stock", "buy_batch", "keep_money", "daily_buy_money",
|
||
"hatch_max_star", "gift_enabled", "gift_liked_only", "quest_enabled", "quest_accept", "quest_city", "quest_items",
|
||
"quest_monsters", "quest_money", "quest_battles", "quest_reserves", "keep_better_quality", "gift_auto_representative")
|
||
for name in names:
|
||
widget = getattr(self, name)
|
||
signal = (widget.toggled if isinstance(widget, W.QAbstractButton) else
|
||
widget.currentIndexChanged if isinstance(widget, W.QComboBox) else
|
||
widget.valueChanged if isinstance(widget, W.QAbstractSpinBox) else widget.textChanged)
|
||
signal.connect(self.settings_changed)
|
||
for widget in self.yield_stars.values():
|
||
widget.toggled.connect(self.settings_changed)
|
||
for key in asdict(ProgressionPolicy()):
|
||
if key == "enabled":
|
||
continue
|
||
widget = getattr(self, "progression_" + key)
|
||
signal = (widget.toggled if isinstance(widget, W.QAbstractButton) else
|
||
widget.currentIndexChanged if isinstance(widget, W.QComboBox) else
|
||
widget.valueChanged if hasattr(widget, "valueChanged") else widget.textChanged)
|
||
signal.connect(self.progression_settings_changed)
|
||
|
||
def settings_changed(self, *args):
|
||
if not self.closed and not self.loading_config and hasattr(self, "auto_save_timer"):
|
||
self.auto_save_timer.start(300)
|
||
|
||
def persist_settings(self):
|
||
if self.closed or self.loading_config:
|
||
return
|
||
value = self.save_config(quiet=True)
|
||
if value is None:
|
||
return
|
||
changed = any(asdict(getattr(self.engine, key)) != value[key]
|
||
for key in ("policy", "quest_policy", "daily_policy", "sweep_policy"))
|
||
progression_changed = asdict(getattr(self.engine, "progression_policy", ProgressionPolicy())) != value["progression_policy"]
|
||
changed = changed or progression_changed
|
||
local_selection_changed = any(getattr(self.engine.policy, key) != value["policy"][key]
|
||
for key in ("gift_auto_representative", "keep_better_quality"))
|
||
self.update_policy(value)
|
||
if progression_changed:
|
||
self.progression_views = None
|
||
if self.presentation_active and self.tabs.currentWidget() in (self.progression_page, self.battle_records_page):
|
||
self.request_progression_views(force=True)
|
||
if local_selection_changed:
|
||
self.pending_preview = True
|
||
self.preview_cultivation()
|
||
elif changed and self.monitoring and self.strategy_toggle.isChecked():
|
||
if self.busy:
|
||
self.pending_execute = True
|
||
else:
|
||
self.next_poll = 0
|
||
self.arm_hatching()
|
||
self.arm_gifting()
|
||
self.statusBar().showMessage("规则已保存,当前请求完成后应用" if self.pending_policy else "规则已自动保存并应用", 3000)
|
||
return value
|
||
|
||
def preview_cultivation(self):
|
||
if self.closed or self.busy:
|
||
return
|
||
self.pending_preview = False
|
||
if self.engine.snapshot is None:
|
||
return
|
||
engine = self.engine
|
||
def preview():
|
||
try:
|
||
return engine.snapshot, engine.plans(), "培养对象已根据已有数据在本地更新"
|
||
except (ValueError, TypeError, KeyError, AttributeError, OSError) as error:
|
||
return engine.snapshot, [], f"本地策略暂不可用:{type(error).__name__}: {error}"
|
||
self.submit("policy_preview", preview)
|
||
|
||
def save_config(self, *args, quiet=False):
|
||
try:
|
||
value = self.config_value()
|
||
self.state.mkdir(parents=True, exist_ok=True)
|
||
temporary = self.state / "settings.tmp"
|
||
temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||
temporary.replace(self.state / "settings.json")
|
||
if not quiet:
|
||
self.report("已保存当前角色的策略;会话单独加密保存")
|
||
return value
|
||
except (ValueError, OSError):
|
||
self.statusBar().showMessage("设置尚未保存,请检查输入格式及本地目录", 5000)
|
||
|
||
def export_policies(self):
|
||
path, _ = W.QFileDialog.getSaveFileName(self, "导出全部策略", f"ranch-policies-{APP_VERSION}.json", "策略文件 (*.json)")
|
||
if not path:
|
||
return
|
||
try:
|
||
value = portable_config(self.config_value(), self.engine.snapshot)
|
||
Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||
self.report("已导出全部策略;文件不包含账号、密码、Token、会话或本机路径")
|
||
except (OSError, ValueError, TypeError) as error:
|
||
self.report("策略导出失败:" + str(error))
|
||
|
||
def import_policies(self):
|
||
if self.busy:
|
||
self.report("请等待当前操作完成,再导入策略")
|
||
return
|
||
path, _ = W.QFileDialog.getOpenFileName(self, "导入全部策略", "", "策略文件 (*.json)")
|
||
if not path:
|
||
return
|
||
try:
|
||
config = import_config(json.loads(Path(path).read_text(encoding="utf-8-sig")), self.engine.snapshot)
|
||
self.stop_workflow()
|
||
self.load_config(self.config_value() | config)
|
||
self.persist_settings()
|
||
policy = self.read_policy()
|
||
matched = len(policy.feed_targets) + len(policy.gift_targets)
|
||
self.report(f"已导入并保存策略;已匹配 {matched} 个当前账号的喂养/赠礼目标;顶部策略开关保持关闭")
|
||
except (OSError, ValueError, TypeError, KeyError) as error:
|
||
self.report("策略导入失败:" + str(error))
|
||
|
||
def load_config(self, value=None):
|
||
path = self.state / "settings.json"
|
||
if value is None and not path.exists():
|
||
return
|
||
if hasattr(self, "auto_save_timer"):
|
||
self.auto_save_timer.stop()
|
||
self.loading_config = True
|
||
try:
|
||
if value is None:
|
||
value = json.loads(path.read_text(encoding="utf-8"))
|
||
progression = checked_progression_policy(value.get("progression_policy", {}))
|
||
sizes = value.get("log_sizes", [420, 140])
|
||
if isinstance(sizes, list) and len(sizes) == 2 and all(isinstance(v, int) and v >= 0 for v in sizes) and sum(sizes) > 0:
|
||
self.log_sizes = sizes
|
||
self.log_splitter.setSizes(sizes)
|
||
blocker = C.QSignalBlocker(self.show_log)
|
||
self.show_log.setChecked(value.get("log_visible", True))
|
||
del blocker
|
||
self.log.setVisible(self.show_log.isChecked())
|
||
self.show_log.setText("隐藏日志" if self.show_log.isChecked() else "显示日志")
|
||
policy = Policy(**value.get("policy", {}))
|
||
daily = DailyPolicy(**value.get("daily_policy", {}))
|
||
self.daily_enabled.setChecked(daily.enabled)
|
||
for key, check in self.daily_checks.items():
|
||
check.setChecked(key in daily.selected)
|
||
sweep = SweepPolicy(**value.get("sweep_policy", {}))
|
||
self.map_rules = copy.deepcopy(sweep.rules)
|
||
self.map_enabled.setChecked(sweep.enabled)
|
||
self.map_keep_ti.setValue(sweep.keep_stamina)
|
||
self.map_team.setCurrentIndex(max(0, self.map_team.findData(sweep.team)))
|
||
self.load_progression_policy(progression)
|
||
self.egg_rules = copy.deepcopy(policy.egg_rules)
|
||
self.feed_targets = copy.deepcopy(policy.feed_targets)
|
||
if not self.feed_targets and policy.feed_target:
|
||
self.feed_targets[str(policy.feed_target)] = 1
|
||
self.gift_targets = copy.deepcopy(policy.gift_targets)
|
||
self.gift_items = copy.deepcopy(policy.gift_items)
|
||
self.gift_enabled.setChecked(policy.gift_enabled)
|
||
self.gift_liked_only.setChecked(policy.gift_liked_only)
|
||
self.gift_auto_representative.setChecked(policy.gift_auto_representative)
|
||
self.keep_better_quality.setChecked(policy.keep_better_quality)
|
||
blocker = C.QSignalBlocker(self.interval)
|
||
self.interval.setCurrentIndex(max(0, self.interval.findData(value.get("interval", 30))))
|
||
del blocker
|
||
for widget, data in ((self.strategy, policy.strategy), (self.protect_quality, policy.protect_quality), (self.egg_order, policy.egg_order),
|
||
(self.market, policy.market_id), (self.hatch_max_star, policy.hatch_max_star)):
|
||
widget.setCurrentIndex(max(0, widget.findData(data)))
|
||
for widget, number in ((self.protect_star, policy.protect_star), (self.coin_exp, policy.coins_per_exp), (self.min_gold, policy.min_gold_per_hour), (self.min_exp, policy.min_exp_per_hour)):
|
||
widget.setValue(number)
|
||
self.fill.setChecked(policy.fill)
|
||
for widget, checked in ((self.buy_eggs, policy.buy), (self.collect, policy.collect), (self.dispatch, policy.dispatch), (self.feed, policy.feed)):
|
||
widget.setChecked(checked)
|
||
self.buy_ten.setChecked(policy.buy_ten)
|
||
self.allow_single_draw.setChecked(policy.allow_single_draw)
|
||
for widget, number in ((self.egg_stock, policy.egg_stock), (self.buy_batch, policy.buy_batch), (self.keep_money, policy.keep_money), (self.daily_buy_money, policy.daily_buy_money)):
|
||
widget.setValue(number)
|
||
for star, check in self.yield_stars.items():
|
||
check.setChecked(star in value.get("yield_stars", [1, 2, 3, 4, 5]))
|
||
self.ranch_enabled.setChecked(policy.enabled)
|
||
quest = QuestPolicy(**value.get("quest_policy", {}))
|
||
self.quest_enabled.setChecked(quest.enabled)
|
||
self.quest_accept.setChecked(quest.accept)
|
||
self.quest_city.setValue(quest.city)
|
||
self.quest_items.setChecked(quest.allow_items)
|
||
self.quest_monsters.setChecked(quest.allow_monsters)
|
||
self.quest_money.setValue(quest.max_money)
|
||
self.quest_battles.setChecked(quest.battle_tasks)
|
||
self.quest_reserves.setText(",".join(f"{k}:{v}" for k, v in quest.item_reserves.items()))
|
||
self.reserved_types.setText(",".join(map(str, policy.reserved_types)))
|
||
self.reserve_eggs.setText(",".join(f"{k}:{v}" for k, v in policy.reserved_eggs.items()))
|
||
self.restore_room = policy.room_id
|
||
self.catalog.overrides = value.get("overrides", {})
|
||
self.render_egg_rules()
|
||
self.render_catalog()
|
||
self.update_workflow_status()
|
||
self.monsters.render_signature = None
|
||
if self.latest_render:
|
||
self.render_current_page()
|
||
except (OSError, ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.report("设置无法完整读取,请检查输入:" + str(error))
|
||
finally:
|
||
self.loading_config = False
|
||
|
||
def closeEvent(self, event):
|
||
self.closed = True
|
||
self.cancel_progression()
|
||
self.timer.stop()
|
||
self.hatch_timer.stop()
|
||
self.analysis_page.row_batch.stop()
|
||
self.progression_table.row_batch.stop()
|
||
self.battle_records_table.row_batch.stop()
|
||
self.pending_progression_view = False
|
||
self.pending_monster_view = False
|
||
self.pending_schedule = False
|
||
self.pending_policy = None
|
||
if hasattr(self, "auto_save_timer"):
|
||
self.auto_save_timer.stop()
|
||
if hasattr(self.eggs, "row_batch"):
|
||
self.eggs.row_batch.stop()
|
||
for name in ("map_render_timer", "monster_render_timer"):
|
||
timer = getattr(self, name, None)
|
||
if timer:
|
||
timer.stop()
|
||
self.pending_refresh = None
|
||
self.engine.auto = False
|
||
self.monitoring = False
|
||
if self.busy:
|
||
self.close_after_job = True
|
||
self.setEnabled(False)
|
||
event.ignore()
|
||
return
|
||
if self.logout_phase == "waiting":
|
||
self.finish_logout()
|
||
self.save_login_info(quiet=True)
|
||
self.save_config(quiet=True)
|
||
if self.engine.client:
|
||
self.engine.client.persist_session()
|
||
self.engine.client.close()
|
||
event.accept()
|
||
|
||
|
||
def main():
|
||
import sys
|
||
app = W.QApplication(sys.argv)
|
||
app.setApplicationName("牧场辅助")
|
||
from .accounts_gui import AccountsWindow
|
||
window = AccountsWindow()
|
||
window.show()
|
||
return app.exec()
|