Files
myrzx_bot/ranch_assistant/gui.py
T

2353 lines
126 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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 .exploration import ExplorePolicy
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
from .exploration_gui import ExplorationPages, prepare_exploration_rows, prepare_exploration_members
APP_VERSION = "1.2.0"
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(ExplorationPages, 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.pending_exploration_view = False
self.monster_data_pending = False
self.pending_schedule = False
self.automation_generation = 0
self.next_explore = float("inf")
self.next_breakthrough = float("inf")
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.breakthrough_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)])
self.breakthrough_settings = W.QPushButton("潜能突破设置")
self.breakthrough_settings.setToolTip("定位当前魔物的自动突破目标和优先级;使用材料补满四项潜能再提升阶段,不是同种喂养突破。")
self.breakthrough_settings.clicked.connect(self.monsters.reveal_breakthrough)
for widget in (self.monster_view, self.monster_room, self.lock_monsters, self.unlock_monsters,
self.breakthrough_settings, 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("喂养与赠礼分别设置目标及优先级(数字小的先执行)。同种突破最高4级,每只同种素材增加1点突破经验;普通经验等级与潜能阶段分别计算。勾选“自动突破目标”即授权先补满四项潜能、再提升潜能阶段,消耗对应元素材料并遵守物品/委托保留量;不购买材料,不消耗金币或氪金。参考属性不含装备、羁绊或全局加成。")
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.monsters.breakthrough_changed.connect(self.monster_breakthrough_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.exploration_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.exploration_page, 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条件:新魔物与牧场已保留的同种最高资质比较,依次按S项数、A项数、B项数、四项成长各自归一化后的平均值排序,严格更高才额外保留,同分不额外保留。")
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 self.explore_enabled.isChecked() or bool(policy.breakthrough_targets)
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.automation_generation += 1
self.set_strategy_checked(False)
self.engine.auto = False
self.cancel_progression()
self.pending_execute = False
self.next_gift = float("inf")
self.next_explore = self.next_breakthrough = 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.explore_enabled.isChecked(), "探险"), (bool(self.breakthrough_targets), "突破"),
(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 monster_breakthrough_changed(self, mid, enabled, priority):
if enabled:
self.breakthrough_targets[str(mid)] = priority
else:
self.breakthrough_targets.pop(str(mid), None)
self.settings_changed()
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", {}))
policies["explore_policy"] = ExplorePolicy.from_dict(value.get("explore_policy", {}))
if self.busy:
self.pending_policy = policies
return False
explore = policies.pop("explore_policy")
self.apply_explore_policy(explore)
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", "automation", "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)
if kind != "connected" and self.presentation_active and not self.closed and self.tabs.currentWidget() is self.exploration_page:
views.exploration = prepare_exploration_rows(engine)
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
explore = policies.pop("explore_policy", self.engine.explore_policy)
self.apply_explore_policy(explore)
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
self.arm_hatching()
self.arm_gifting()
self.arm_extended_automation()
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.pending_exploration_view and not self.closed and self.presentation_active and self.tabs.currentWidget() is self.exploration_page:
self.pending_exploration_view = False
self.refresh_exploration()
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", "automation", "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)
if kind in ("poll", "automation") and self.engine.pending_recovery_due():
self.next_poll = min(self.next_poll, time.monotonic() + 120)
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()
self.arm_extended_automation()
elif kind == "exploration_view":
self.accept_exploration_view(value)
elif kind.startswith("exploration_members:"):
self.accept_exploration_members(*value)
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
pending = self.engine.battle_journal.pending(self.engine.snapshot) if self.engine.snapshot is not None else None
recovering_map = not self.engine.demo and bool(pending and pending.get("kind") == "map_battle")
self.monitoring = recovering_map
if recovering_map:
self.engine.last_pending_check = time.monotonic()
self.next_poll = self.engine.last_pending_check + 120
self.stop_workflow()
self.report(("策略已暂停;后台每2分钟核对挑战记录:" if recovering_map else "已停止:") + 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(),
breakthrough_targets=copy.deepcopy(self.breakthrough_targets),
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")
engine, generation = self.engine, self.automation_generation
def dispatch():
if automated and (generation != self.automation_generation or engine is not self.engine):
return engine.snapshot, [], "自动化设置已变化,未开始的自动轮询已取消"
return engine.poll(hatch_only=hatch_only, defer_hatch=not hatch_only)
self.run_job("hatch" if hatch_only else "poll", dispatch)
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 run_extended_automation(self):
if self.busy or not self.monitoring or not self.strategy_toggle.isChecked() or not self.engine.snapshot:
return
now = time.monotonic()
if now >= self.next_explore:
self.run_fast_automation("explore")
elif now >= self.next_breakthrough and self.breakthrough_targets:
self.run_fast_automation("breakthrough")
def run_fast_automation(self, kind):
if self.busy or self.closed or self.logout_phase is not None:
return
self.automation_generation += 1
setattr(self, "next_" + kind, float("inf"))
generation = self.automation_generation
engine = self.engine
def dispatch():
if generation != self.automation_generation or engine is not self.engine:
return engine.snapshot, [], "自动化设置已变化,未开始的快速任务已取消"
return engine.poll_automation(kind)
self.submit("automation", dispatch)
def arm_extended_automation(self):
active = self.monitoring and self.strategy_toggle.isChecked() and not self.closed and self.engine.snapshot is not None
plans = self.latest_render[1] if self.latest_render else []
# Pending writes use the existing reconciliation cadence. In particular,
# a completed team must not keep a one-second claim loop alive while a
# finish or task/battle request is unresolved.
pending = active and (self.engine.explore_planner.pending(self.engine.snapshot)
or self.engine._progression_pending() or self.engine._breakthrough_pending)
if pending:
self.next_explore = float("inf")
explore_ready = active and not pending and any(action.path and (action.kind == "explore_finish"
or action.kind == "explore_start" and self.explore_enabled.isChecked()) for action in plans)
breakthrough = active and bool(self.breakthrough_targets) and any(
action.kind in ("potential", "breakthrough") for action in plans)
now = time.monotonic()
explore_delay = 1.0 if explore_ready else None
if active and not pending and self.engine.snapshot is not None:
for team in self.engine.snapshot.raw.get("exploreTeams") or []:
if not isinstance(team, dict) or team.get("status") not in (1, "1"):
continue
remaining = self.engine.explore_planner.remaining(self.engine.snapshot, team)
if remaining is not None:
delay = max(1.0, remaining + 1)
explore_delay = delay if explore_delay is None else min(explore_delay, delay)
for kind, enabled, dispatch_delay in (("explore", explore_delay is not None, explore_delay or 1.0),
("breakthrough", breakthrough, 1.0)):
attribute = "next_" + kind
deadline = getattr(self, attribute)
setattr(self, attribute, (now + dispatch_delay if deadline == float("inf") else deadline) if enabled else float("inf"))
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.run_fast_automation("hatch")
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.run_fast_automation("gift")
elif self.monitoring and self.strategy_toggle.isChecked() and now >= min(self.next_explore, self.next_breakthrough):
self.run_extended_automation()
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()
if page is not self.exploration_page:
self.exploration_table.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.exploration_page:
if self.prepared_views and self.prepared_views.snapshot is snapshot and self.prepared_views.exploration is not None:
self.accept_exploration_view(self.prepared_views.exploration)
elif not self.busy:
self.refresh_exploration()
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, self.breakthrough_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()),
"explore_policy": self.read_explore_policy().to_dict(),
"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",
"explore_enabled", "explore_reserve_ti",
"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.automation_generation += 1
self.auto_save_timer.start(300)
self.arm_hatching()
self.arm_gifting()
self.arm_extended_automation()
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 or self.engine.explore_policy.to_dict() != value["explore_policy"]
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) + len(policy.breakthrough_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", {}))
explore = ExplorePolicy.from_dict(value.get("explore_policy", self.read_explore_policy().to_dict()))
self.apply_explore_policy(explore)
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_allow_challenge.setChecked(sweep.allow_challenge)
self.map_keep_ti.setValue(sweep.keep_stamina)
self.map_allow_special.setChecked(sweep.allow_special)
self.map_keep_tickets.setValue(sweep.keep_tickets)
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.breakthrough_targets = copy.deepcopy(policy.breakthrough_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()