Files
myrzx_bot/ranch_assistant/gui.py
T

1859 lines
100 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 io
import json
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 .farming import Adb, FarmConfig, FarmRunner
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 IntegerInput, use_native_scrollbars
from .login import PasswordLogin, device_id, server_labels
from .quests import QuestPolicy
from .daily import DailyPolicy
from .sweeping import SweepPolicy
from .activity_gui import ActivityPages
from .capture import PAGES, load_buttons, read_profile, saved_profiles, save_page
from .credentials import CredentialStore
from .debug import TraceLog
from .debug_window import DebugWindow
from .sessions import SessionStore, identity
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()
class Screen(W.QWidget):
selected = C.Signal(object)
def __init__(self, selectable=True):
super().__init__()
self.selectable = selectable
self.setMinimumSize(220, 300)
self.image, self.pixmap, self.anchor, self.current = None, None, None, None
def set_image(self, image):
self.image = image
stream = io.BytesIO()
image.save(stream, format="PNG")
self.pixmap = G.QPixmap()
self.pixmap.loadFromData(stream.getvalue())
self.update()
def rect_image(self):
size = self.pixmap.size().scaled(self.size(), C.Qt.AspectRatioMode.KeepAspectRatio)
return C.QRect((self.width() - size.width()) // 2, (self.height() - size.height()) // 2, size.width(), size.height())
def paintEvent(self, event):
painter = G.QPainter(self)
if self.pixmap is None:
painter.drawText(self.rect(), C.Qt.AlignmentFlag.AlignCenter,
"截图后拖动框选按钮" if self.selectable else "点击上方对应页面的截图按钮,这里显示预览")
return
painter.drawPixmap(self.rect_image(), self.pixmap)
if self.anchor is not None and self.current is not None:
painter.setPen(G.QPen(C.Qt.GlobalColor.red, 2))
painter.drawRect(C.QRect(self.anchor, self.current).normalized())
def mousePressEvent(self, event):
if self.selectable and self.pixmap is not None and self.rect_image().contains(event.position().toPoint()):
self.anchor = self.current = event.position().toPoint()
def mouseMoveEvent(self, event):
if self.anchor is not None:
self.current = event.position().toPoint()
self.update()
def mouseReleaseEvent(self, event):
if self.anchor is None:
return
rectangle = C.QRect(self.anchor, event.position().toPoint()).normalized().intersected(self.rect_image())
target = self.rect_image()
scale = self.image.width / target.width()
box = (int((rectangle.left() - target.left()) * scale), int((rectangle.top() - target.top()) * scale),
int((rectangle.right() - target.left()) * scale), int((rectangle.bottom() - target.top()) * scale))
self.anchor = self.current = None
self.update()
if box[2] - box[0] >= 12 and box[3] - box[1] >= 12:
self.selected.emit(box)
def spin(low, high, value, decimals=False):
widget = W.QDoubleSpinBox() if decimals else W.QSpinBox()
widget.setRange(low, high)
widget.setValue(value)
return widget
def combo(options):
widget = W.QComboBox()
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):
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 = W.QTableWidgetItem()
if isinstance(value, (int, float)):
item.setData(C.Qt.ItemDataRole.DisplayRole, value)
else:
item.setText(str(value))
widget.setItem(i, j, item)
widget.setSortingEnabled(sorting)
class Window(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.connection_guard = None
self.login_guard = None
self.device_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.farm = FarmRunner(Adb(), self.catalog, self.state)
self.busy, self.monitoring = False, False
self.active_job = None
self.next_poll = self.next_farm = 0
self.client_pending = None
self.password_login_result = None
self.capture_profile = None
self.egg_rules = {}
self.feed_targets = {}
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([("5秒", 5), ("10秒", 10), ("30秒", 30), ("60秒", 60)])
self.interval.setCurrentIndex(1)
self.start_monitor = W.QPushButton("开始监控")
self.start_monitor.setCheckable(True)
self.start_monitor.toggled.connect(self.toggle_monitor)
refresh = W.QPushButton("刷新 / 预览策略")
refresh.clicked.connect(self.refresh)
self.execute = W.QCheckBox("自动执行已启用策略")
self.execute.toggled.connect(self.execution_changed)
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.mode, self.summary, self.interval, self.start_monitor, refresh, self.execute, 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 = table(["魔物ID", "名称", "星", "等级 / 当前上限", "资质 攻/防/血/敏", "位置", "锁定", "管理范围",
"喂养目标", "喂养优先级", "突破等级", "参考攻击", "参考防御", "参考生命", "参考敏捷", "好感", "喜欢的物品"])
self.rooms_table = table(["牧场ID", "名称", "类型", "当前魔物", "容量", "空位"])
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()
self.sync_growth_button = W.QPushButton("同步孵化 / 成长")
self.sync_growth_button.setToolTip("读取服务器成长结算和成熟资质;本次只同步,不派遣或喂养")
self.sync_growth_button.clicked.connect(self.request_growth_sync)
slot_tools.addWidget(self.sync_growth_button)
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.save_config), ("刷新背包", 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.tabs.addTab(self.egg_page, "背包魔物蛋")
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("选择魔物后可锁定 / 解锁,也可右键操作")
for widget in (self.lock_monsters, self.unlock_monsters, self.monster_selection):
monster_tools.addWidget(widget)
monster_tools.addStretch()
monster_layout.addLayout(monster_tools)
detail_note = W.QLabel("勾选“喂养目标”并设置优先级(数字小的先喂);当前突破上限满级后转下一个目标。参考属性含等级、潜能、好感和升星,不含装备、羁绊或全局加成。")
detail_note.setWordWrap(True)
monster_layout.addWidget(detail_note)
monster_layout.addWidget(self.monsters)
self.monsters.itemSelectionChanged.connect(self.update_monster_actions)
self.monsters.cellDoubleClicked.connect(lambda row, column: self.show_monster_detail(row))
self.tabs.addTab(self.monster_page, "魔物")
self.room_page = W.QWidget()
room_layout = W.QVBoxLayout(self.room_page)
room_tools = W.QHBoxLayout()
for label, currency in (("新建牧场(金币)", "money"), ("新建牧场(氪金)", "ke")):
button = W.QPushButton(label)
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
room_tools.addWidget(button)
room_tools.addStretch()
room_layout.addLayout(room_tools)
self.room_status = W.QLabel("已开启的牧场列在下方;新建前会显示费用并确认。")
self.room_status.setWordWrap(True)
room_layout.addWidget(self.room_status)
room_layout.addWidget(self.rooms_table)
self.tabs.addTab(self.room_page, "牧场概况")
self.policy_tab()
self.automation_tab()
self.yield_tab()
self.quests_tab()
self.maps_tab()
self.daily_tab()
self.farm_tab()
self.capture_tab()
self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"])
self.tabs.addTab(self.plans, "执行计划")
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.refresh_capture_profiles()
self.render_catalog()
self.install_refresh_menus()
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))
save_login = W.QPushButton("保存登录信息")
save_login.clicked.connect(self.save_login_info)
login_options = W.QHBoxLayout()
for widget in (self.remember_password, show_password, save_login):
login_options.addWidget(widget)
login_options.addStretch()
self.login_button = W.QPushButton("账号密码登录并获取区服")
self.login_button.clicked.connect(self.password_login)
self.server_list = W.QComboBox()
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 = W.QComboBox()
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)
form.addRow(demo_button)
note = W.QLabel("账号密码和登录会话自动加密保存。各账号独立运行,登录后再开启自动执行。")
note.setWordWrap(True)
form.addRow(note)
self.tabs.addTab(tab, "登录")
def policy_tab(self):
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)])
self.protect_quality.setCurrentIndex(1)
self.target = combo([("未设置:不自动喂养", 0)])
self.target_level = spin(1, 100, 70)
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.target), ("喂养达到此等级后停止", self.target_level), ("收取到牧场", self.room),
("额外保留魔物编号(逗号分隔)", self.reserved_types),
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
for label, widget in rows:
form.addRow(label, widget)
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)
form.addRow("实际喂养上限", self.target_status)
self.target.currentIndexChanged.connect(self.update_target_status)
self.target_level.valueChanged.connect(self.update_target_status)
form.addRow(W.QLabel("仅处理本次运行观察到的培育室魔物;已有牧场魔物不作为自动派遣/喂养素材。\n锁定、羁绊、已装备、队伍/探索中的魔物会保留。蛋的手机本地锁定无法从服务器读取,请设置保留蛋数量。"))
save = W.QPushButton("保存设置")
save.clicked.connect(self.save_config)
form.addRow(save)
self.tabs.addTab(tab, "牧场策略")
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)
buttons = W.QHBoxLayout()
self.workflow_start = W.QPushButton("开始执行勾选功能")
self.workflow_start.clicked.connect(self.start_workflow)
monitor = W.QPushButton("仅监控")
monitor.clicked.connect(self.monitor_only)
self.workflow_stop = W.QPushButton("停止执行")
self.workflow_stop.setToolTip("停止后不再发送下一项操作;已经发出的请求会正常返回。")
self.workflow_stop.clicked.connect(self.stop_workflow)
preview = W.QPushButton("刷新 / 预览")
preview.clicked.connect(self.refresh)
for widget in (self.workflow_start, monitor, self.workflow_stop, preview):
buttons.addWidget(widget)
layout.addLayout(buttons)
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("优先十连;库存缺口累计到10再补货,无蛋且金币不足时单抽")
self.buy_ten.setChecked(True)
self.dispatch = W.QCheckBox("成熟后按策略自动派遣")
self.collect = W.QCheckBox("保留或待喂养的魔物自动收取到牧场")
self.feed = W.QCheckBox("按策略喂养选定目标(受当前突破上限限制)")
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.buy_ten), ("单抽时每批上限", self.buy_batch),
("至少保留金币", self.keep_money), ("每日购蛋金币额度(0=不购买)", self.daily_buy_money),
("孵蛋", self.fill), ("派遣", self.dispatch),
("收取", self.collect), ("喂养", self.feed)):
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("先在“背包魔物蛋”勾选并配置规则,再开始自动孵蛋。按手动优先级装填,成熟后按各行选择派遣、喂养或保留。\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资质。应用后仍需开始执行。")
save = W.QPushButton("保存当前配置")
save.clicked.connect(self.save_config)
bottom = W.QHBoxLayout()
bottom.addWidget(preset)
bottom.addWidget(save)
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, "自动孵蛋")
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.protect_star.valueChanged.connect(self.update_workflow_status)
self.update_workflow_status()
def execution_changed(self, value):
if not value:
self.engine.auto = False
self.pending_execute = False
self.trace.emit("info", "自动执行状态", scope="local", enabled=value, monitoring=self.monitoring)
self.update_workflow_status()
def start_workflow(self):
try:
policy = self.read_policy()
other = self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked()
if not (policy.enabled and any((policy.buy, policy.fill, policy.dispatch, policy.collect, policy.feed))) and not other:
self.report("请先勾选至少一项功能,并启用对应策略")
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)
return
except ValueError:
self.report("请先修正牧场策略中的保留编号和数量")
return
self.save_config(quiet=True)
self.start_monitor.setChecked(True)
self.execute.setChecked(True)
self.next_poll = 0
if self.busy:
self.pending_execute = True
self.report("当前请求完成后开始执行勾选功能")
else:
self.refresh(automated=True)
self.update_workflow_status()
def monitor_only(self):
self.stop_workflow()
self.start_monitor.setChecked(True)
self.refresh()
def stop_workflow(self):
self.execute.setChecked(False)
self.engine.auto = False
self.pending_execute = False
self.update_workflow_status()
def request_growth_sync(self):
if self.busy or self.closed:
self.report("请等待当前请求完成后再同步成长")
return
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
except ValueError:
self.report("请先修正孵蛋规则中的编号和保留数量")
return
self.stop_workflow()
self.submit("growth_sync", self.engine.sync_growth)
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.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.execute.isChecked() and self.monitoring
state = "执行中" if active else "仅监控(不结算成长、不派遣;请点“开始执行”)" if self.monitoring else "已停止(不会自动派遣)"
self.workflow_status.setText(("离线演示 · " if self.engine.demo else "真实角色 · ") + state)
self.workflow_start.setEnabled(not active)
self.workflow_stop.setEnabled(self.execute.isChecked())
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()}。")
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.save_config(quiet=True)
self.update_workflow_status()
self.statusBar().showMessage("孵蛋规则已保存;下一轮按新规则执行", 5000)
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("自动接取条件已满足的委托")
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 farm_tab(self):
tab, horizontal = W.QWidget(), W.QHBoxLayout()
tab.setLayout(horizontal)
form = W.QFormLayout()
horizontal.addLayout(form)
self.adb_path = W.QLineEdit(self.farm.adb.executable)
self.serial = W.QLineEdit()
self.stage = combo([("布丁史莱姆牧场 bd00", "bd00"), ("布丁史莱姆牧场 bd01", "bd01")])
self.stage_level = combo([("普通 / 1", "1"), ("进阶 / 2", "2"), ("精英 / 3", "3")])
self.daily = spin(1, 999, 3)
self.keep_ti = spin(0, 9999, 0)
self.timeout = spin(30, 1200, 240)
self.threshold = spin(0.8, 1.0, 0.96, True)
self.threshold.setSingleStep(0.01)
for label, widget in (("ADB路径", self.adb_path), ("设备编号(单设备可留空)", self.serial), ("目标关卡", self.stage), ("难度", self.stage_level),
("本日轮数上限(自定)", self.daily), ("保留体力", self.keep_ti), ("单轮超时秒数", self.timeout), ("按钮匹配阈值", self.threshold)):
form.addRow(label, widget)
self.template = combo([("进入关卡按钮(必需)", "entry"), ("胜利结算按钮(必需)", "victory"),
("关卡名称区域(必需,仅识别)", "stage"), ("触摸开始倒计时", "countdown"), ("自动战斗未开启图标", "auto_off"), ("结算下一步按钮", "continue"), ("失败标识(只检测不点击)", "defeat")])
form.addRow("框选的按钮类型", self.template)
guide = W.QPushButton("打开ADB实战截图配置(扫荡无需截图)")
guide.clicked.connect(lambda: self.tabs.setCurrentWidget(self.capture_scroll))
form.addRow(guide)
capture = W.QPushButton("手工标定(可选):截图并在右侧框选")
capture.clicked.connect(self.capture)
form.addRow(capture)
self.template_status = W.QLabel("尚未标定")
form.addRow(self.template_status)
self.start_farm = W.QPushButton("开始布丁牧场刷图")
self.start_farm.setCheckable(True)
self.start_farm.toggled.connect(self.toggle_farm)
form.addRow(self.start_farm)
self.farm_status = W.QLabel("已停止")
self.farm_status.setWordWrap(True)
form.addRow(self.farm_status)
note = W.QLabel("先到“页面截图配置”保存关卡准备和胜利结算页,生成配置后加载。\n开始后手机保持游戏前台;开启游戏内自动战斗,或提供关闭状态截图。\n开战前核对体力、入场券和本日轮数。")
note.setWordWrap(True)
form.addRow(note)
self.screen = Screen()
self.screen.selected.connect(self.save_template)
horizontal.addWidget(self.screen, 1)
self.tabs.addTab(tab, "体力刷图")
def capture_tab(self):
tab, layout = W.QWidget(), W.QVBoxLayout()
tab.setLayout(layout)
self.capture_page_widget = tab
scroll = W.QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(tab)
self.capture_scroll = scroll
layout.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
note = W.QLabel("此页仅用于ADB手机实战;地图接口扫荡和每日事务不需要截图。\n先在“体力刷图”选择设备、关卡和难度。你玩到对应页面时点击该行截图,无需手工框选;截图不会自动点击或切换手机页面。")
note.setWordWrap(True)
layout.addWidget(note)
self.capture_target = W.QLabel()
layout.addWidget(self.capture_target)
self.capture_profiles = W.QComboBox()
self.capture_profiles.setPlaceholderText("尚未保存截图;截图后会按设备和分辨率列出配置")
self.capture_profiles.currentIndexChanged.connect(self.select_capture_profile)
layout.addWidget(self.capture_profiles)
self.capture_rows = W.QTableWidget(len(PAGES), 4)
self.capture_rows.verticalHeader().setDefaultSectionSize(max(28, self.fontMetrics().height() + 12))
self.capture_rows.setHorizontalHeaderLabels(["页面", "截图需要包含", "操作", "状态"])
self.capture_rows.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.capture_rows.cellClicked.connect(self.preview_capture)
self.capture_rows.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents)
self.capture_rows.horizontalHeader().setStretchLastSection(True)
for index, (key, name, description, required) in enumerate(PAGES):
self.capture_rows.setItem(index, 0, W.QTableWidgetItem(name + ("(必需)" if required else "(可选)")))
self.capture_rows.setItem(index, 1, W.QTableWidgetItem(description))
button = W.QPushButton("截取此页面")
button.clicked.connect(lambda checked=False, page=key: self.capture_page(page))
self.capture_rows.setCellWidget(index, 2, button)
self.capture_rows.setItem(index, 3, W.QTableWidgetItem("未截图"))
self.capture_rows.setRowHeight(index, max(28, button.sizeHint().height() + 4))
height = self.capture_rows.horizontalHeader().sizeHint().height() + sum(self.capture_rows.rowHeight(i) for i in range(len(PAGES))) + 30
self.capture_rows.setFixedHeight(height)
layout.addWidget(self.capture_rows)
line = W.QHBoxLayout()
refresh = W.QPushButton("检查已保存截图")
refresh.clicked.connect(self.refresh_capture_profiles)
load = W.QPushButton("加载已生成的按钮配置")
load.clicked.connect(self.load_capture_buttons)
folder = W.QPushButton("打开截图文件夹")
folder.clicked.connect(self.open_capture_folder)
line.addWidget(refresh)
line.addWidget(load)
line.addWidget(folder)
layout.addLayout(line)
self.capture_path = W.QLineEdit()
self.capture_path.setReadOnly(True)
layout.addWidget(self.capture_path)
self.capture_preview = Screen(selectable=False)
self.capture_preview.setMinimumHeight(140)
layout.addWidget(self.capture_preview, 1)
self.tabs.addTab(scroll, "页面截图配置")
self.tabs.setTabToolTip(self.tabs.indexOf(scroll), "仅用于ADB手机实战;接口扫荡和每日事务无需截图")
self.stage.currentIndexChanged.connect(self.refresh_capture_profiles)
self.stage_level.currentIndexChanged.connect(self.refresh_capture_profiles)
self.serial.editingFinished.connect(self.refresh_capture_profiles)
def capture_page(self, page):
if self.busy:
self.report("正在处理上一项操作,请稍候再截图")
return
self.update_farm_config()
self.start_farm.setChecked(False)
self.start_monitor.setChecked(False)
adb = Adb(self.adb_path.text(), self.serial.text().strip())
stage_id, level = self.stage.currentData(), self.stage_level.currentData()
def sample():
if not adb.foreground():
raise RuntimeError("请先把游戏切到对应页面,再点击截图")
serial = adb.serial or adb.run("get-serialno").strip()
image = adb.screenshot()
path, profile = save_page(self.state, image, serial, stage_id, level, page)
return path, profile, image
self.submit("page_sample", sample)
def refresh_capture_profiles(self, *args):
profiles = saved_profiles(self.state, self.stage.currentData(), self.stage_level.currentData(), self.serial.text().strip())
old = str(self.capture_profile) if self.capture_profile else None
self.capture_profiles.blockSignals(True)
self.capture_profiles.clear()
for path, profile in profiles:
width, height = profile["resolution"]
self.capture_profiles.addItem(f"{profile['device_serial']} / {width}×{height} / 已拍 {len(profile['captures'])} 页", str(path))
index = self.capture_profiles.findData(old)
self.capture_profiles.setCurrentIndex(max(0, index) if profiles else -1)
self.capture_profiles.blockSignals(False)
self.select_capture_profile()
def select_capture_profile(self, *args):
value = self.capture_profiles.currentData()
self.capture_profile = Path(value) if value else None
self.capture_preview.image = self.capture_preview.pixmap = None
self.capture_preview.update()
self.refresh_capture_status()
def preview_capture(self, row, column):
if self.capture_profile is None:
return
try:
from PIL import Image
profile = read_profile(self.capture_profile, self.state)
record = profile["captures"].get(PAGES[row][0])
if record:
path = (self.capture_profile.parent / record["file"]).resolve()
if path.is_relative_to(self.state.resolve()):
with Image.open(path) as image:
self.capture_preview.set_image(image.convert("RGB"))
except (OSError, ValueError, KeyError) as error:
self.report(f"截图预览无法读取:{error}")
def open_capture_folder(self):
path = self.capture_profile.parent if self.capture_profile else self.state / "capture_profiles"
path.mkdir(parents=True, exist_ok=True)
G.QDesktopServices.openUrl(C.QUrl.fromLocalFile(str(path.resolve())))
def refresh_capture_status(self, *args):
stage_id, level = self.stage.currentData(), self.stage_level.currentData()
self.capture_target.setText(f"当前目标:{self.stage.currentText()} / 难度 {level}")
profile = None
if self.capture_profile and self.capture_profile.exists():
try:
candidate = read_profile(self.capture_profile, self.state)
if str(candidate["stage_id"]) == stage_id and str(candidate["stage_level"]) == level:
profile = candidate
except (OSError, ValueError, KeyError):
self.report("截图配置无法读取,请重新截图")
for index, (key, _, _, _) in enumerate(PAGES):
record = (profile or {}).get("captures", {}).get(key)
self.capture_rows.item(index, 3).setText(record["captured_at"] if record else "未截图")
self.capture_path.setText(str(self.capture_profile) if profile else "截图后会显示配置文件位置")
def load_capture_buttons(self):
if self.busy or self.farm.running:
self.report("请先停止自动战斗,再加载配置")
return
if self.capture_profile is None:
self.report("尚未保存页面截图")
return
try:
self.update_farm_config()
self.farm.config.templates = load_buttons(self.capture_profile, self.state, self.stage.currentData(), self.stage_level.currentData(), self.serial.text().strip())
self.farm.config.capture_profile = str(self.capture_profile.relative_to(self.state.resolve()))
self.template_status.setText("已加载页面按钮配置:" + ", ".join(self.farm.config.templates))
self.save_config()
except FileNotFoundError:
self.report("页面截图已保存;按钮配置尚未生成,截图齐后可直接读取这些文件进行配置")
except (ValueError, KeyError, TypeError, OSError) as error:
self.report(str(error))
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, "<隐藏>")
self.log.appendPlainText(time.strftime("%H:%M:%S ") + message)
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():
row = self.monsters.indexAt(position).row()
if row >= 0 and not self.monsters.selectionModel().isRowSelected(row, C.QModelIndex()):
self.monsters.selectRow(row)
menu.addSeparator()
detail = menu.addAction("查看魔物详情")
detail.setEnabled(bool(self.selected_monster_ids()))
detail.triggered.connect(lambda: self.show_monster_detail(self.monsters.currentRow()))
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))
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 [int(self.monsters.item(index.row(), 0).text()) for index in self.monsters.selectionModel().selectedRows()
if self.monsters.item(index.row(), 0)]
def show_monster_detail(self, row):
if row < 0 or not self.monsters.item(row, 0) or self.engine.snapshot is None:
return
mid = int(self.monsters.item(row, 0).text())
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.capture_scroll:
self.refresh_capture_profiles()
else:
self.refresh()
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.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False)
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.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False)
self.active_identity = key
self.state = self.profile_root / "roles" / key
self.capture_profile = None
self.farm = FarmRunner(Adb(), self.catalog, self.state)
self.load_config(copy.deepcopy(self.default_config))
self.load_config()
self.refresh_capture_profiles()
self.render_catalog()
def submit(self, kind, function):
if self.busy or self.closed:
return
self.busy = True
self.update_monster_actions()
job = Job(kind, function)
self.active_job = job
job.signals.result.connect(self.result)
job.signals.error.connect(self.error)
job.signals.done.connect(self.job_done)
self.pool.start(job)
@C.Slot()
def job_done(self):
self.busy = False
self.update_monster_actions()
self.active_job = None
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_execute and self.monitoring and self.execute.isChecked() and not self.closed:
self.pending_execute = False
C.QTimer.singleShot(0, lambda: self.refresh(automated=True))
def result(self, kind, value):
try:
self.apply_result(kind, value)
except (ValueError, TypeError, KeyError, AttributeError) as error:
self.error("显示数据时出错:" + str(error))
def apply_result(self, kind, value):
if kind in ("poll", "monster_lock", "manual_monsters", "expansion", "growth_sync", "daily_claim"):
snapshot, plans, message = value
self.render(snapshot, plans)
self.report(message)
self.reload_saved_sessions()
if "策略暂不可用" in message:
self.execute.setChecked(False)
elif kind == "heartbeat":
self.report(value)
elif kind == "capture":
self.screen.set_image(value)
elif kind == "page_sample":
captured_path, profile, image = value
self.capture_profile = captured_path
self.refresh_capture_profiles()
if self.capture_profile == captured_path:
self.capture_preview.set_image(image)
self.save_config()
count = len(profile["captures"])
self.report(f"已保存 {count}/{len(PAGES)} 个页面样本:{captured_path.parent}")
if {"stage_ready", "victory"}.issubset(profile["captures"]):
self.report("必需页面已齐,可告知助手直接读取本地截图并生成配置;其余页面按需补拍")
elif kind == "farm":
self.farm_status.setText(value)
if not self.farm.running:
self.start_farm.setChecked(False)
if "结算完成" in value:
self.next_poll = 0
self.report(value)
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.engine.snapshot = snapshot
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.execute.setChecked(False)
self.account.setReadOnly(True)
self.render(snapshot, [])
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
fill_table(self.plans, [[action.kind, action.description] for action in self.engine.plans()])
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.automation_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()} 个区服,请选择后进入")
def error(self, message):
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)
self.login_status.setText("操作失败,调试窗口中保留了请求和响应")
self.engine.auto = False
self.engine.heartbeat_enabled = False
self.execute.setChecked(False)
self.monitoring = False
self.start_monitor.setChecked(False)
self.farm.stop()
self.start_farm.setChecked(False)
self.report("已停止:" + message)
self.statusBar().showMessage(message)
def read_policy(self):
reserved = [int(v.strip()) for v in self.reserved_types.text().split(",") if v.strip()]
eggs = {}
for item in self.reserve_eggs.text().split(","):
if item.strip():
type_id, count = item.split(":")
eggs[str(int(type_id))] = max(0, int(count))
return Policy(enabled=self.ranch_enabled.isChecked(), strategy=self.strategy.currentData(), protect_star=self.protect_star.value(), protect_quality=self.protect_quality.currentData(),
feed_target=self.target.currentData() or 0, target_level=self.target_level.value(), room_id=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(),
manual_eggs=True, egg_rules=copy.deepcopy(self.egg_rules),
feed_targets=copy.deepcopy(self.feed_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):
if self.busy or self.closed:
return
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
self.engine.auto = self.execute.isChecked() and automated and self.monitoring
self.next_poll = time.monotonic() + self.interval.currentData()
self.submit("poll", self.engine.poll)
except ValueError:
if automated:
self.error("请核对策略中的魔物编号和保留数量")
else:
self.engine.auto = False
self.engine.policy = Policy(enabled=False)
self.engine.quest_policy = QuestPolicy()
self.report("策略格式有误,本次仅刷新角色数据")
self.submit("poll", self.engine.poll)
def toggle_monitor(self, value):
self.monitoring = value
self.start_monitor.setText("停止监控" if value else "开始监控")
if value:
self.next_poll = 0
else:
self.execute.setChecked(False)
self.update_workflow_status()
def schedule(self):
if self.busy or self.closed:
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 (self.monitoring or self.farm.running) and now >= self.next_poll:
self.refresh(automated=True)
elif self.farm.running and now >= self.next_farm and self.engine.snapshot:
self.next_farm = now + 2
self.submit("farm", lambda: self.farm.tick(self.engine.snapshot))
def render(self, snapshot, plans):
master = snapshot.raw["master"]
self.summary.setText(f"{master.get('roleName', '')} | 金币 {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 '未激活'})。选择“未开启”的普通坑位后可扩建。")
self.render_egg_rules()
monster_rows = [[m["id"], m.get("nicName") or self.catalog.monster(m["typeId"]).get("name", "未知"), self.catalog.monster(m["typeId"]).get("star", "?"),
f"{m.get('level', 1)} / {self.catalog.max_level(m) or '?'}", self.catalog.quality_text(m), "培育室 · " + snapshot.phase_text(m, self.catalog) if m.get("process") == 2 else f"牧场 {m.get('roomId', 0)}", "系统锁定" if m.get("sysLock") else "是" if m.get("lock") else "否",
"本次培育" if int(m["id"]) in self.engine.planner.managed else "已有:不自动处理", "", "", m.get("potentialLevel", "?"),
*self.catalog.reference_stats(m), m.get("feel", "?"), self.catalog.likes_text(m["typeId"])] for m in snapshot.raw["monsters"]]
fill_table(self.monsters, monster_rows, sorting=False)
for row_index, mon in enumerate(snapshot.raw["monsters"]):
mid = str(mon["id"])
check, priority = W.QCheckBox(), IntegerInput()
priority.setRange(1, 999)
priority.setValue(self.feed_targets.get(mid, 100))
check.setChecked(mid in self.feed_targets)
check.setEnabled(mon.get("process") == 3)
priority.setFixedWidth(76)
def changed(*args, mid=mid, check=check, priority=priority):
if check.isChecked():
self.feed_targets[mid] = priority.value()
self.feed.setChecked(True)
self.collect.setChecked(True)
else:
self.feed_targets.pop(mid, None)
self.save_config(quiet=True)
self.update_target_status()
check.toggled.connect(changed)
priority.valueChanged.connect(changed)
self.monsters.setCellWidget(row_index, 8, check)
self.monsters.setCellWidget(row_index, 9, priority)
self.monsters.item(row_index, 16).setToolTip(self.catalog.likes_text(mon["typeId"]))
self.monsters.setSortingEnabled(True)
rooms = []
for room in snapshot.raw["rooms"]:
info = self.catalog.data["room_info"].get(str(room.get("typeId")), {})
used = sum(int(mon.get("roomId") or 0) == int(room["id"]) and mon.get("process") == 3 for mon in snapshot.raw["monsters"])
capacity = info.get("maxNum")
rooms.append([room["id"], room.get("name") or info.get("name") or "牧场", room.get("typeId", ""), used,
capacity if capacity is not None else "未知", max(0, int(capacity) - used) if capacity is not None else "未知"])
fill_table(self.rooms_table, rooms)
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"{'演示数据' if self.engine.demo else '真实角色数据'} | 培育坑位 {len(snapshot.raw['stacks'])}(使用 {incubating}) | 魔物蛋 {len(eggs)} 类 / {sum(int(egg.get('num') or 0) for egg in eggs)} 枚 | 魔物 {len(snapshot.raw['monsters'])} | 牧场 {len(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()
try:
quest_policy = self.read_quest_policy()
quest_rows = self.engine.tasks.rows(snapshot, quest_policy, self.read_policy())
fill_table(self.quests_table, [[key, name, status,
self.catalog.data["task_info"][key].get("reward", {}).get("money", 0),
self.catalog.data["task_info"][key].get("reward", {}).get("ke", 0), text] for key, name, status, text, _ in quest_rows])
self.render_maps()
self.render_daily()
except (ValueError, TypeError, KeyError, AttributeError) as error:
self.report("基础数据已显示;委托或地图暂不可用:" + str(error))
left = snapshot.raw.get("history", {}).get("loopTaskNum", "未知")
self.quest_summary.setText(f"今日剩余可接次数:{left};当前委托:{len(self.engine.tasks.current(snapshot))}")
self.update_combo(self.target, [("未设置:不自动喂养", 0)] + [(f"{self.catalog.monster(m['typeId']).get('name')} Lv.{m.get('level', 1)}/{self.catalog.max_level(m) or '?'} #{m['id']}", int(m["id"])) for m in snapshot.raw["monsters"] if m.get("process") == 3])
self.update_combo(self.room, [("自动选择有空位的牧场", 0)] + [(f"牧场 {r['id']}", int(r["id"])) for r in snapshot.raw["rooms"]])
if hasattr(self, "restore_target") and not self.engine.demo:
self.target.setCurrentIndex(max(0, self.target.findData(self.restore_target)))
self.room.setCurrentIndex(max(0, self.room.findData(self.restore_room)))
del self.restore_target
self.update_target_status()
if not self.engine.demo:
self.reqid.setValue(self.engine.client.session.reqid)
self.reqsid.setValue(self.engine.client.session.reqsid)
@staticmethod
def update_combo(widget, rows):
previous = widget.currentData()
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.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
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:
return
self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False)
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.active_identity = None
self.state = self.profile_root
self.capture_profile = None
self.farm = FarmRunner(Adb(), self.catalog, self.state)
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.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
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.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
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 capture(self):
if not self.busy:
self.farm.adb = Adb(self.adb_path.text(), self.serial.text().strip())
self.submit("capture", self.farm.adb.screenshot)
def save_template(self, box):
if self.farm.running:
self.error("请先停止刷图再修改按钮标定")
return
self.state.mkdir(parents=True, exist_ok=True)
name = self.template.currentData()
filename = name + ".png"
self.screen.image.crop(box).save(self.state / filename)
self.farm.config.templates[name] = {"file": filename, "box": list(box), "screen": [self.screen.image.width, self.screen.image.height], "stage_id": self.stage.currentData(), "stage_level": self.stage_level.currentData()}
self.farm.config.capture_profile = ""
self.template_status.setText("已标定:" + ", ".join(self.farm.config.templates))
self.save_config()
def toggle_farm(self, value):
if not value:
self.farm.stop()
self.start_farm.setText("开始布丁牧场刷图")
return
if self.map_enabled.isChecked() and self.execute.isChecked():
self.start_farm.setChecked(False)
self.report("请先停止地图页的接口扫荡,再开始手机实战")
return
if self.busy or self.engine.demo or self.engine.snapshot is None:
self.start_farm.setChecked(False)
self.report("请先连接真实手机会话,等待刷新完成后再开始刷图")
return
try:
self.update_farm_config()
if self.device_guard and not self.device_guard(self.farm.adb.serial):
self.start_farm.setChecked(False)
self.report("此手机已由另一个账号页签刷图,请先停止该页签或选择其他设备")
return
self.farm.start()
self.start_farm.setText("停止刷图")
self.next_poll = self.next_farm = 0
self.save_config()
except Exception as error:
self.start_farm.setChecked(False)
self.report(str(error))
def update_farm_config(self):
self.farm.adb = Adb(self.adb_path.text(), self.serial.text().strip())
self.farm.config = FarmConfig(stage_id=self.stage.currentData(), stage_level=self.stage_level.currentData(), daily_limit=self.daily.value(), keep_stamina=self.keep_ti.value(),
timeout=self.timeout.value(), threshold=self.threshold.value(), templates=self.farm.config.templates, capture_profile=self.farm.config.capture_profile)
def config_value(self):
self.update_farm_config()
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()),
"farm": asdict(self.farm.config), "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()],
"adb_path": self.adb_path.text(), "serial": self.serial.text().strip(), "interval": self.interval.currentData(),
"capture_profile": str(self.capture_profile.relative_to(self.state.resolve())) if self.capture_profile else None}
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("已保存当前角色的策略和标定;会话单独加密保存")
except ValueError:
self.error("设置格式不正确,未保存")
def load_config(self, value=None):
path = self.state / "settings.json"
if value is None and not path.exists():
return
try:
if value is None:
value = json.loads(path.read_text(encoding="utf-8"))
sizes = value.get("log_sizes", [420, 140])
if isinstance(sizes, list) and len(sizes) == 2 and all(isinstance(v, int) and v >= 0 for v in sizes) and sum(sizes) > 0:
self.log_sizes = sizes
self.log_splitter.setSizes(sizes)
blocker = C.QSignalBlocker(self.show_log)
self.show_log.setChecked(value.get("log_visible", True))
del blocker
self.log.setVisible(self.show_log.isChecked())
self.show_log.setText("隐藏日志" if self.show_log.isChecked() else "显示日志")
policy = Policy(**value.get("policy", {}))
daily = DailyPolicy(**value.get("daily_policy", {}))
self.daily_enabled.setChecked(daily.enabled)
for key, check in self.daily_checks.items():
check.setChecked(key in daily.selected)
sweep = SweepPolicy(**value.get("sweep_policy", {}))
self.map_rules = copy.deepcopy(sweep.rules)
self.map_enabled.setChecked(sweep.enabled)
self.map_keep_ti.setValue(sweep.keep_stamina)
self.map_team.setCurrentIndex(max(0, self.map_team.findData(sweep.team)))
self.egg_rules = copy.deepcopy(policy.egg_rules)
self.feed_targets = copy.deepcopy(policy.feed_targets)
for widget, data in ((self.strategy, policy.strategy), (self.protect_quality, policy.protect_quality), (self.egg_order, policy.egg_order), (self.interval, value.get("interval", 10)),
(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.target_level, policy.target_level), (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)
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_target, self.restore_room = policy.feed_target, policy.room_id
self.farm.config = FarmConfig(**value.get("farm", {}))
if self.stage.findData(self.farm.config.stage_id) < 0:
info = self.catalog.data["stage_info"].get(self.farm.config.stage_id, {})
self.stage.addItem(info.get("name", self.farm.config.stage_id), self.farm.config.stage_id)
self.stage.setCurrentIndex(max(0, self.stage.findData(self.farm.config.stage_id)))
self.stage_level.setCurrentIndex(max(0, self.stage_level.findData(self.farm.config.stage_level)))
for widget, number in ((self.daily, self.farm.config.daily_limit), (self.keep_ti, self.farm.config.keep_stamina), (self.timeout, self.farm.config.timeout), (self.threshold, self.farm.config.threshold)):
widget.setValue(number)
self.adb_path.setText(value.get("adb_path", self.adb_path.text()))
self.serial.setText(value.get("serial", ""))
self.catalog.overrides = value.get("overrides", {})
self.template_status.setText("已标定:" + ", ".join(self.farm.config.templates))
if value.get("capture_profile"):
candidate = (self.state / value["capture_profile"]).resolve()
if candidate.is_relative_to(self.state.resolve()):
self.capture_profile = candidate
self.refresh_capture_status()
self.render_egg_rules()
self.render_catalog()
self.update_workflow_status()
except Exception:
self.report("旧设置无法读取,已使用默认设置")
def closeEvent(self, event):
self.closed = True
self.timer.stop()
if hasattr(self, "activity_save_timer"):
self.activity_save_timer.stop()
self.pending_refresh = None
self.engine.auto = False
self.monitoring = False
self.farm.stop()
if self.busy:
self.close_after_job = True
self.setEnabled(False)
event.ignore()
return
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()