2165 lines
116 KiB
Python
2165 lines
116 KiB
Python
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, RowBatch, 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 .presentation import Presented, prepare_views, monster_rows
|
||
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
|
||
from .inventory_gui import ITEM_TYPES, InventoryTable, RanchView
|
||
from .policy_io import portable_policy, import_policy
|
||
|
||
APP_VERSION = "1.1.0"
|
||
|
||
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.presentation_active = True
|
||
self.latest_render = None
|
||
self.prepared_views = 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 = {}
|
||
self.gift_targets = {}
|
||
self.gift_items = {}
|
||
central = W.QWidget()
|
||
layout = W.QVBoxLayout(central)
|
||
self.setCentralWidget(central)
|
||
toolbar = W.QHBoxLayout()
|
||
self.mode = W.QLabel("未登录")
|
||
self.summary = W.QLabel()
|
||
self.data_summary = W.QLabel("等待读取培育室、背包和牧场状态")
|
||
self.interval = combo([("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.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.monsters.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.Interactive)
|
||
for column, width in enumerate((115, 140, 45, 120, 150, 140, 80, 130, 90, 110, 85, 90, 90, 90, 90, 90, 220, 65, 110)):
|
||
self.monsters.setColumnWidth(column, width)
|
||
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.inventory = InventoryTable(self.catalog)
|
||
self.inventory.gifts_changed.connect(self.gift_items_changed)
|
||
self.inventory_tabs = W.QTabWidget()
|
||
self.inventory_tabs.addTab(self.egg_page, "魔物蛋")
|
||
item_page = W.QWidget()
|
||
item_layout = W.QVBoxLayout(item_page)
|
||
item_tools = W.QHBoxLayout()
|
||
self.item_search = W.QLineEdit()
|
||
self.item_search.setPlaceholderText("按物品名称或类型编号筛选")
|
||
self.item_category = combo([(label, value) for value, label in ITEM_TYPES])
|
||
item_tools.addWidget(self.item_category)
|
||
item_tools.addWidget(self.item_search, 1)
|
||
item_layout.addLayout(item_tools)
|
||
item_layout.addWidget(self.inventory)
|
||
self.inventory_tabs.addTab(item_page, "物品与装备")
|
||
self.tabs.addTab(self.inventory_tabs, "背包")
|
||
self.egg_page = self.inventory_tabs
|
||
self.egg_rules_page = self.inventory_tabs.widget(0)
|
||
self.monster_page = W.QWidget()
|
||
monster_layout = W.QVBoxLayout(self.monster_page)
|
||
monster_tools = W.QHBoxLayout()
|
||
self.lock_monsters = W.QPushButton("锁定选中")
|
||
self.unlock_monsters = W.QPushButton("解锁选中")
|
||
self.lock_monsters.clicked.connect(lambda: self.change_monster_lock(True))
|
||
self.unlock_monsters.clicked.connect(lambda: self.change_monster_lock(False))
|
||
self.monster_selection = W.QLabel("选择魔物后可锁定 / 解锁,也可右键操作")
|
||
self.monster_view = combo([("按牧场分组", 1), ("全部魔物", 0)])
|
||
self.monster_room = combo([("全部牧场", 0)])
|
||
for widget in (self.monster_view, self.monster_room, self.lock_monsters, self.unlock_monsters, self.monster_selection):
|
||
monster_tools.addWidget(widget)
|
||
for label, currency in (("新建牧场(金币)", "money"), ("新建牧场(氪金)", "ke")):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
|
||
monster_tools.addWidget(button)
|
||
monster_tools.addStretch()
|
||
monster_layout.addLayout(monster_tools)
|
||
detail_note = W.QLabel("勾选“喂养目标”并设置优先级(数字小的先喂);当前突破上限满级后转下一个目标。参考属性含等级、潜能、好感和升星,不含装备、羁绊或全局加成。")
|
||
detail_note.setWordWrap(True)
|
||
monster_layout.addWidget(detail_note)
|
||
self.ranch_view = RanchView(self.rooms_table, self.monsters)
|
||
monster_layout.addWidget(self.ranch_view)
|
||
self.monsters.itemSelectionChanged.connect(self.update_monster_actions)
|
||
self.monsters.cellDoubleClicked.connect(lambda row, column: self.show_monster_detail(row))
|
||
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)
|
||
self.room_page.hide()
|
||
self.room_page = self.monster_page
|
||
self.tabs.addTab(self.room_page, "牧场")
|
||
self.policy_tab(embedded=True)
|
||
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, "执行计划")
|
||
order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page,
|
||
self.quests_table.parentWidget(), self.yields.parentWidget(), self.daily_page, self.map_page,
|
||
self.automation_page, self.start_farm.parentWidget(), self.capture_scroll, self.plans]
|
||
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.item_search.textChanged.connect(lambda text: self.inventory.set_filter(text, self.item_category.currentData()))
|
||
self.item_category.currentIndexChanged.connect(lambda: self.inventory.set_filter(self.item_search.text(), self.item_category.currentData()))
|
||
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.refresh_capture_profiles()
|
||
self.render_catalog()
|
||
self.install_refresh_menus()
|
||
self.tabs.currentChanged.connect(self.render_current_page)
|
||
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)
|
||
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)])
|
||
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锁定、羁绊、已装备、队伍/探索中的魔物会保留。蛋的手机本地锁定无法从服务器读取,请设置保留蛋数量。"))
|
||
self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,在牧场勾选目标)")
|
||
self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品")
|
||
self.gift_liked_only.setChecked(True)
|
||
form.addRow("好感培养", self.gift_enabled)
|
||
form.addRow(self.gift_liked_only)
|
||
self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。")
|
||
self.gift_status.setWordWrap(True)
|
||
form.addRow(self.gift_status)
|
||
for widget in (self.gift_enabled, self.gift_liked_only):
|
||
widget.toggled.connect(self.update_gift_status)
|
||
save = W.QPushButton("保存设置")
|
||
save.clicked.connect(self.save_config)
|
||
form.addRow(save)
|
||
if embedded:
|
||
return tab
|
||
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)
|
||
for label, function in (("导入策略…", self.import_policies), ("导出策略…", self.export_policies)):
|
||
button = W.QPushButton(label)
|
||
button.clicked.connect(function)
|
||
bottom.addWidget(button)
|
||
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_tab(embedded=True)
|
||
self.automation_tabs = W.QTabWidget()
|
||
self.automation_tabs.addTab(settings_scroll, "孵蛋设置")
|
||
self.automation_tabs.addTab(policy_tab, "牧场与赠礼策略")
|
||
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.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 gift_items_changed(self, rules, key):
|
||
self.gift_items = rules
|
||
if rules[key]["enabled"]:
|
||
self.gift_enabled.setChecked(True)
|
||
self.save_config(quiet=True)
|
||
self.update_gift_status()
|
||
|
||
def update_gift_status(self, *args):
|
||
if not hasattr(self, "gift_status"):
|
||
return
|
||
self.gift_status.setText(f"已允许 {sum(bool(r.get('enabled')) for r in self.gift_items.values())} 种物品;已选择 {len(self.gift_targets)} 个目标;每次赠礼一件,达到当前好感上限或处于赠礼间隔时停止。")
|
||
|
||
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)
|
||
self.monster_render_signature = None
|
||
if self.latest_render:
|
||
self.render_monsters(self.latest_render[0])
|
||
|
||
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 logout_and_clear(self):
|
||
if self.busy:
|
||
self.report("请等待当前操作完成,再清除登录记录")
|
||
return
|
||
keys = [entry["session_id"] for entry in self.session_store.entries()]
|
||
text = "将退出登录,并删除当前账号页签保存的会话和账号密码。\n培养策略、日志及其他账号的记录不受影响。"
|
||
if W.QMessageBox.question(self, "清除登录记录", text, W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No,
|
||
W.QMessageBox.StandardButton.No) != W.QMessageBox.StandardButton.Yes:
|
||
return
|
||
self.demo()
|
||
try:
|
||
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):
|
||
self.report("部分登录记录未能删除,请检查本地状态目录")
|
||
|
||
def submit(self, kind, function):
|
||
if self.busy or self.closed:
|
||
return
|
||
self.busy = True
|
||
self.update_monster_actions()
|
||
catalog, engine = self.catalog, self.engine
|
||
def background():
|
||
started = time.perf_counter()
|
||
value = function()
|
||
if kind in ("poll", "monster_lock", "manual_monsters", "expansion", "growth_sync", "daily_claim", "connected"):
|
||
snapshot = value[1] if kind == "connected" else value[0]
|
||
managed = set() if kind == "connected" else set(engine.planner.managed)
|
||
preparing = time.perf_counter()
|
||
views = prepare_views(catalog, snapshot, managed)
|
||
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.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))
|
||
|
||
@C.Slot(str, object)
|
||
def result(self, kind, value):
|
||
metrics = None
|
||
if isinstance(value, Presented):
|
||
self.prepared_views = value.views
|
||
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", "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 kind == "poll" and self.engine.last_executed and self.execute.isChecked() and self.monitoring:
|
||
self.next_poll = time.monotonic() + .15
|
||
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.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):
|
||
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=getattr(self, "restore_target", self.target.currentData() or 0), target_level=self.target_level.value(), 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(),
|
||
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(),
|
||
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):
|
||
self.latest_render = (snapshot, plans)
|
||
self.engine.snapshot = 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 set_presentation_active(self, active):
|
||
self.presentation_active = active
|
||
if not active:
|
||
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()
|
||
elif self.latest_render:
|
||
self.render_current_page()
|
||
|
||
def render_current_page(self, *args):
|
||
if self.closed or not self.presentation_active or not self.latest_render:
|
||
return
|
||
snapshot, plans = self.latest_render
|
||
page = self.tabs.currentWidget()
|
||
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()
|
||
if page is not self.egg_page and hasattr(self.eggs, "row_batch"):
|
||
self.eggs.row_batch.stop()
|
||
if page is not self.inventory_tabs and hasattr(self.inventory, "row_batch"):
|
||
self.inventory.row_batch.stop()
|
||
try:
|
||
if page is self.monster_page:
|
||
self.render_rooms(snapshot)
|
||
self.render_monsters(snapshot)
|
||
elif page is self.inventory_tabs:
|
||
if self.inventory_tabs.currentWidget() is self.egg_rules_page:
|
||
self.render_egg_rules()
|
||
else:
|
||
self.inventory.set_data(snapshot, self.gift_items)
|
||
elif page is self.egg_page:
|
||
self.render_egg_rules()
|
||
elif page is self.room_page:
|
||
self.render_rooms(snapshot)
|
||
elif page is self.quests_table.parentWidget():
|
||
self.render_quests(snapshot)
|
||
elif page is self.map_page:
|
||
self.render_maps()
|
||
elif page is self.daily_page:
|
||
self.render_daily()
|
||
elif page is self.target.parentWidget() or 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.monster_source == repr(snapshot.raw["monsters"]) and views.managed == managed:
|
||
rows = views.monsters
|
||
else:
|
||
rows = monster_rows(self.catalog, snapshot, managed, self.monster_room.currentData() or 0)
|
||
room_id = self.monster_room.currentData() or 0
|
||
if room_id:
|
||
rows = monster_rows(self.catalog, snapshot, managed, room_id)
|
||
visible_monsters = [mon for mon in snapshot.raw["monsters"] if not room_id or mon.get("process") == 3 and int(mon.get("roomId") or 0) == room_id]
|
||
signature = (rows, dict(self.feed_targets), dict(self.gift_targets), room_id)
|
||
if getattr(self, "monster_render_signature", None) == signature:
|
||
return
|
||
if not hasattr(self, "monster_render_timer"):
|
||
self.monster_render_timer = RowBatch(self)
|
||
self.monsters.setSortingEnabled(False)
|
||
self.monsters.setRowCount(len(rows))
|
||
def apply(entry):
|
||
row_index, mon, values = entry
|
||
for column, value in enumerate(values):
|
||
item = self.monsters.item(row_index, column)
|
||
if item is None:
|
||
item = W.QTableWidgetItem()
|
||
self.monsters.setItem(row_index, column, item)
|
||
if item.data(C.Qt.ItemDataRole.DisplayRole) != value:
|
||
item.setData(C.Qt.ItemDataRole.DisplayRole, value)
|
||
mid = str(mon["id"])
|
||
existing = self.monsters.cellWidget(row_index, 8)
|
||
if existing and existing.property("monster_id") == mid:
|
||
priority = self.monsters.cellWidget(row_index, 9)
|
||
gift_check, gift_priority = self.monsters.cellWidget(row_index, 17), self.monsters.cellWidget(row_index, 18)
|
||
blockers = [C.QSignalBlocker(existing), C.QSignalBlocker(priority), C.QSignalBlocker(gift_check), C.QSignalBlocker(gift_priority)]
|
||
existing.setChecked(mid in self.feed_targets)
|
||
existing.setEnabled(mon.get("process") == 3)
|
||
if not priority.hasFocus():
|
||
priority.setValue(self.feed_targets.get(mid, 100))
|
||
gift_check.setChecked(mid in self.gift_targets)
|
||
gift_priority.setValue(self.gift_targets.get(mid, 100))
|
||
return
|
||
check, priority = W.QCheckBox(), IntegerInput()
|
||
check.setProperty("monster_id", mid)
|
||
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(str(values[16]))
|
||
gift_check, gift_priority = W.QCheckBox(), IntegerInput()
|
||
gift_check.setChecked(mid in self.gift_targets)
|
||
gift_check.setEnabled(mon.get("process") == 3)
|
||
gift_priority.setRange(1, 999)
|
||
gift_priority.setValue(self.gift_targets.get(mid, 100))
|
||
gift_priority.setEnabled(mon.get("process") == 3)
|
||
def gift_changed(*args, mid=mid, check=gift_check, priority=gift_priority):
|
||
if check.isChecked():
|
||
self.gift_targets[mid] = priority.value()
|
||
self.gift_enabled.setChecked(True)
|
||
else:
|
||
self.gift_targets.pop(mid, None)
|
||
self.save_config(quiet=True)
|
||
self.update_gift_status()
|
||
gift_check.toggled.connect(gift_changed)
|
||
gift_priority.valueChanged.connect(gift_changed)
|
||
self.monsters.setCellWidget(row_index, 17, gift_check)
|
||
self.monsters.setCellWidget(row_index, 18, gift_priority)
|
||
def finish():
|
||
self.monster_render_signature = copy.deepcopy(signature)
|
||
self.monsters.setSortingEnabled(True)
|
||
self.monster_render_timer.start(((i, mon, values) for i, (mon, values) in enumerate(zip(visible_monsters, rows))), apply, finish)
|
||
|
||
def refresh_target_choices(self, 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"):
|
||
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
|
||
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_rooms(self, snapshot):
|
||
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)
|
||
|
||
def render_quests(self, snapshot):
|
||
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])
|
||
|
||
@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.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 export_policies(self):
|
||
path, _ = W.QFileDialog.getSaveFileName(self, "导出培养策略", "ranch-policies-1.1.0.json", "策略文件 (*.json)")
|
||
if not path:
|
||
return
|
||
try:
|
||
value = portable_policy(self.read_policy(), 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:
|
||
policy = import_policy(json.loads(Path(path).read_text(encoding="utf-8-sig")), self.engine.snapshot)
|
||
self.stop_workflow()
|
||
self.load_config({"policy": asdict(policy)})
|
||
self.save_config(quiet=True)
|
||
missing = (len(policy.feed_targets) + len(policy.gift_targets))
|
||
self.report(f"已导入并保存培养策略;已匹配 {missing} 个当前账号的喂养/赠礼目标;自动执行保持停止")
|
||
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
|
||
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)
|
||
self.gift_targets = copy.deepcopy(policy.gift_targets)
|
||
self.gift_items = copy.deepcopy(policy.gift_items)
|
||
self.gift_enabled.setChecked(policy.gift_enabled)
|
||
self.gift_liked_only.setChecked(policy.gift_liked_only)
|
||
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()
|
||
self.monster_render_signature = None
|
||
if self.latest_render:
|
||
self.render_current_page()
|
||
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()
|
||
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
|
||
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()
|