您的位置：首页 > 财经 > 产业 > 儿童7一8岁手工_微信营销成_长沙正规竞价优化推荐_seo优化公司排名

儿童7一8岁手工_微信营销成_长沙正规竞价优化推荐_seo优化公司排名

2024/12/26 1:57:33 来源：https://blog.csdn.net/qq_42883074/article/details/142651105  浏览:  次   关键词：儿童7一8岁手工_微信营销成_长沙正规竞价优化推荐_seo优化公司排名
儿童7一8岁手工_微信营销成_长沙正规竞价优化推荐_seo优化公司排名

项目中关于键鼠的操作，不像我们之前自动化那样一步一步去定义的，而是用C++写了一个记录键鼠的操作，通过回放的方法来实现的

一、服务端创建

1、创建websocket服务器

首先通过事件循环asyncio 和websockets，创建一个持久化的服务端进程，允许客户端来请求

 vi wss.py

import asyncio
import concurrent.futures
import threading
import time
import websockets# 存储所有已连接的客户端
connected_clients = []#处理客户端请求
async def handle_client(websocket):print("客户端连接成功")connected_clients.append(websocket)try:while True:message = await websocket.recv()if message is None:breakprint(f"客户端请求的消息: {message}")# 假设需要回应客户端await websocket.send(f"{message}")except websockets.exceptions.ConnectionClosed:print("Client 连接断开")finally:# 确保移除已断开连接的客户端connected_clients.remove(websocket)async def server_main():# 创建 WebSocket 服务器server = await websockets.serve(handle_client, "localhost", 29943)print("启动服务端成功")try:# 等待服务器关闭await asyncio.Future()except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")import asyncio# 创建一个新的事件循环
loop = asyncio.new_event_loop()# 启动 WebSocket 服务器
try:loop.run_until_complete(server_main())except KeyboardInterrupt:#当用户按下 Ctrl+C 时会引发此异常。通常用来处理用户中断程序的情况。print("Stopping WebSocket server...")finally:# 关闭事件循环loop.close()

代码说明2

import asyncio
import concurrent.futures
import threading
import time
import websockets# 存储所有已连接的客户端
connected_clients = []#处理客户端请求
async def handle_client(websocket):print("客户端连接成功")connected_clients.append(websocket)try:while True:message = await websocket.recv()if message is None:breakprint(f"客户端请求的消息: {message}")# 假设需要回应客户端await websocket.send(f"{message}")except websockets.exceptions.ConnectionClosed:print("Client 连接断开")finally:# 确保移除已断开连接的客户端connected_clients.remove(websocket)async def server_main():'''websockets.serve：这个函数用于创建一个 WebSocket 服务器，它返回一个协程对象。await：等待这个协程对象完成。实际上，websockets.serve 创建了服务器并立即返回，不会等待服务器完全启动，因此这里的 await 主要是用来确保协程函数能够正确执行并返回结果。创建服务器：这个步骤创建了一个监听在本地地址 localhost 的端口 29943 上的 WebSocket 服务器，并指定了处理客户端连接的回调函数 handle_client。:return:'''# 创建 WebSocket 服务器#当有客户端连接到服务端的时候，触发handle_client 处理请求server = await websockets.serve(handle_client, "localhost", 29943)print("启动服务端成功")try:# 等待服务器关闭# asyncio.Future 会开启Future协程, 通过await异步等待他完成# 但是因为没有设置完成条件，所以只会在中断或错误的时候退出,期间一致保持接收客户端请求await asyncio.Future()except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")import asyncio# 创建一个新的事件循环
loop = asyncio.new_event_loop()# 启动 WebSocket 服务器
try:#这个方法会启动事件循环并一直运行，直到提供的协程函数（在这里是#server_main()）完成。如果协程函数中抛出了任何异常，run_until_complete()#会将这个异常重新抛出，这样就可以在try-except 块中捕获并处理它loop.run_until_complete(server_main())except KeyboardInterrupt:#当用户按下 Ctrl+C 时会引发此异常。通常用来处理用户中断程序的情况。print("Stopping WebSocket server...")finally:#close()：这个方法用来关闭事件循环。关闭事件循环可以释放相关资源，并确保所有任务都已经完成或被适当地取消。#finally 块：无论前面的#try 块是否抛出异常，finally 块中的代码都会被执行。这确保了即使在发生异常或用户中断的情况下，事件循环也会被正确关闭# 关闭事件循环loop.close()

2、客户端请求测试

vi wsstest.py

import asyncio
import websocketsasync def client():uri = "ws://localhost:29943"async with websockets.connect(uri) as websocket:print("已连接到服务端")# 发送消息给服务端await websocket.send("我是客户端发送的消息")print("已发送消息到服务端")# 接收服务端返回的消息response = await websocket.recv()print(f"服务端消息返回: {response}")async def main():await client()# 初始化事件循环
loop = asyncio.get_event_loop()# 启动客户端
try:loop.run_until_complete(main())
except KeyboardInterrupt:print("Stopping WebSocket client...")
finally:# 关闭事件循环loop.close()

 

服务端返回

启动服务端成功客户端连接成功
客户端请求的消息: 我是客户端发送的消息
Client 连接断开

客户端返回

已连接到服务端
已发送消息到服务端
服务端消息返回: 我是客户端发送的消息

3、服务端--守护进程运行

上面服务端和客户端正常用起来看着没什么问题，但是我们主要是在ui上面用的，所有东西必须都是异步，不能因为开个服务端就把主进程给占用了，这里服务端做下修改

下面改用threading.Thread 以协程形式运行服务端进程，并将该协程设置为守护进程模式，只有当主进程结束时，才会结束服务端， 方便测试我们先在结尾加个input作为程序的主进程（不退出或者指定方法退出的都行）

 vi wss.py

import asyncio
import concurrent.futures
import sys
import threading
import time
import websockets# 存储所有已连接的客户端
connected_clients = []#处理客户端请求
async def handle_client(websocket):print("客户端连接成功")connected_clients.append(websocket)try:while True:message = await websocket.recv()if message is None:breakprint(f"客户端请求的消息: {message}")# 假设需要回应客户端await websocket.send(f"{message}")except websockets.exceptions.ConnectionClosed:print("Client 连接断开")finally:# 确保移除已断开连接的客户端connected_clients.remove(websocket)async def server_main():server = await websockets.serve(handle_client, "localhost", 29943, max_size=1024 * 1024 * 10)#搭配协程用# 等待 server 对象的 wait_closed 方法返回的一个协程完成。asyncio.gather 是一个用来并发运行多个异步任务的函数# 并且它可以返回这些任务的结果。在这个特定的情况下，gather 只接收了一个任务 server.wait_closed()# 因此它实际上是等待这个特定的任务完成# 等待 server 对象的 wait_closed 方法返回的一个协程完成。try:await asyncio.gather(server.wait_closed())except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")import asyncio# 创建一个新的事件循环
loop = asyncio.new_event_loop()#以协程非主进程形式运行
t = threading.Thread(target=loop.run_until_complete, args=(server_main(),))#协程以守护进程运行
python_var = sys.version_info[1]
if python_var > 8:t.daemon = True
else:t.setDaemon(True)
t.start()print("服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出")
print("这个程序将在未来作为一个协程启动，而非主进程形式")
print("没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭")#主进程（这个我们后面是要把input改为我们ui中的某个触发点的，这里input只是用来演示）
input("回车退出")

4、添加键鼠录制插件

如果是本地主机，可能会报毒给删了，看情况自己做隔离，路径datas/JiaoBen/xxx.exe
exe文件
https://download.csdn.net/download/qq_42883074/89820151

源码
https://download.csdn.net/download/qq_42883074/89858644

5、部署插件服务

首先我们要先将录制的插件服务拉起来，通过subprocess.Popen('"' + "./datas/jiaoben/xxx.exe" + '" "' + "29943" + '"') 在启动插件的时候指定本地服务端端口

wss.py

async def server_main():server = await websockets.serve(handle_client, "localhost", 29943, max_size=1024 * 1024 * 10)#添加下面这个#运行插件服务import subprocesstry:time.sleep(5)# 启动exe程序subprocess.Popen('"' + "./datas/jiaoben/xxx.exe" + '" "' + "29943" + '"')print("插件服务已经启动!")except:print("文件没找到可以能被杀毒软件干掉了 " + "./datas/jiaoben/xxx.exe")#搭配协程用try:await asyncio.gather(server.wait_closed())except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")

返回信息

服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出
这个程序将在未来作为一个协程启动，而非主进程形式
没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭回车退出插件服务已经启动!
客户端连接成功
客户端请求的消息: 是否禁止录制 真

可以看到当插件服务启动后，立刻给我们指定端口开始发送请求

这个插件本身就是支持通过按键来进行录制和回放，这里按F8其实就生效录制了，但我们没有输出所以看不出来

6、日志系统

在做服务端程序的时候，有很多时候我们都不方便直接print把信息打印出来，这里直接用日志模板，将服务端信息写到日志中

logger_module.py

import logging
import os
from logging.handlers import TimedRotatingFileHandler# 创建全局的 logger
logger = logging.getLogger("LenRenAI")
logger.setLevel(logging.DEBUG)
# 创建一个handler，用于将日志输出到控制台
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)log_dir = './log'
if not os.path.exists(log_dir):os.makedirs(log_dir)
# 创建一个handler，用于将日志输出到文件
file_handler = TimedRotatingFileHandler('./log/lanrenai.log', when='midnight', interval=1, backupCount=7)
file_handler.setLevel(logging.DEBUG)# 定义日志消息格式
class CustomFormatter(logging.Formatter):FORMATS = {logging.DEBUG: '%(asctime)s - %(name)s - %(levelname)s - %(message)s',logging.INFO: '%(asctime)s - %(name)s - %(levelname)s - %(message)s',logging.WARNING: '%(asctime)s - %(name)s - %(levelname)s - %(message)s',logging.ERROR: '%(asctime)s - %(name)s - %(levelname)s - %(message)s',logging.CRITICAL: '%(asctime)s - %(name)s - %(levelname)s - %(message)s',}def format(self, record):log_fmt = self.FORMATS.get(record.levelno)formatter = logging.Formatter(log_fmt)return formatter.format(record)# 创建一个formatter格式类
formatter = CustomFormatter()
# 设置消息格式
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
# 将handler添加到logger
logger.addHandler(console_handler)
logger.addHandler(file_handler)

7、添加全局变量

状态_是否回放中 = False
状态_是否暂停 = False
状态_是否开始录制 = False
状态_是否禁止录制 = True
状态_开伞时间 = -1
录制_当前脚本名 = ""
录制_脚本文本 = ""
录制_path = ""
录制_当前任务索引 = -1

8、客户端请求处理变更本地配置

我们在项目中是无法直接判断插件的运行情况的，只能通过定义变量的形式保存在本地作为开关，当请求发生变化的时候，对插件发送请求信息，然后去变更本地的变量配置

#处理客户端请求
from logger_module import logger
async def handle_client(websocket, path):global new_msgtry:# 发送连接成功消息await websocket.send("连接成功")# 添加新连接的客户端到集合中connected_clients.append(websocket)while True:# 接收客户端发送的消息message = await websocket.recv()new_msg = message# print(f"收到消息：{message}")# 处理接收到的消息if message == "是否回放中 真":state.状态_是否回放中 = Trueelif message == "是否回放中 假":state.状态_是否回放中 = Falseelif message == "是否暂停 真":state.状态_是否暂停 = Trueelif message == "是否暂停 假":state.状态_是否暂停 = Falseelif message == "是否开始录制 假":state.状态_是否开始录制 = Falseelif message == "是否开始录制 真":if state.状态_是否禁止录制 == False:logger.info("请按F8结束录制")# state.QT_信号.mysig_tishi.emit(f"请按F8结束录制")state.状态_是否开始录制 = Trueelif message == "是否禁止录制 假":state.状态_是否禁止录制 = Falseelif message == "是否禁止录制 真":state.状态_是否禁止录制 = Trueelif message[:5] == "录制的脚本":state.录制_脚本文本 = message[6:]#保存文件if state.录制_脚本文本 != "":logger.info(state.录制_脚本文本)with open("1111.txt", "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)logger.info("录制完毕!")finally:# 客户端断开连接后，将其移出集合connected_clients.remove(websocket)


 

9、添加发送请求函数

我们需要有一个外部能够调用的函数去对事件信息中的客户端（插件） 发送具体的消息，让插件知道该做什么了（录制、回放），首先我们添加一个send_msg的允许在外部调用事件循环内的函数，通过他去调用事件循环内部的函数

def send_msg(msg="是否回放#@@#假"):'''给躺宝发送指令全部指令  :是否回放#@@#假  /真是否暂停#@@#假  /真是否开始录制#@@#假 /真是否禁止录制#@@#假 /真解析脚本#@@#jiaoben"  jiaoben就是录制的脚本文本 不是文件 是直接文字全局hwnd#@@#12345   12345就是游戏的窗口句柄:param msg: 指令 用 #@@# 分割:return:'''asyncio.run_coroutine_threadsafe(send_to_client(-1, msg), loop)async def send_to_client(client_id, message):if len(connected_clients) > 0:# 查找指定的客户端await connected_clients[client_id].send(message)

下面的send_to_client函数是async，处于事件循环中的，相当于是拿着插件客户端的请求连接，然后通过send将消息 （msg="是否回放#@@#假"） 发送给插件，让他做对应的操作

10、服务端全量代码

import asyncio
import concurrent.futures
import os
import sys
import threading
import time
import websocketsimport state# 存储所有已连接的客户端
connected_clients = []#处理客户端请求
#处理客户端请求
from logger_module import logger
async def handle_client(websocket, path):global new_msgtry:# 发送连接成功消息await websocket.send("连接成功")# 添加新连接的客户端到集合中connected_clients.append(websocket)while True:# 接收客户端发送的消息message = await websocket.recv()new_msg = message# print(f"收到消息：{message}")# 处理接收到的消息if message == "是否回放中 真":state.状态_是否回放中 = Trueelif message == "是否回放中 假":state.状态_是否回放中 = Falseelif message == "是否暂停 真":state.状态_是否暂停 = Trueelif message == "是否暂停 假":state.状态_是否暂停 = Falseelif message == "是否开始录制 假":state.状态_是否开始录制 = Falseelif message == "是否开始录制 真":if state.状态_是否禁止录制 == False:logger.info("请按F8结束录制")# state.QT_信号.mysig_tishi.emit(f"请按F8结束录制")state.状态_是否开始录制 = Trueelif message == "是否禁止录制 假":state.状态_是否禁止录制 = Falseelif message == "是否禁止录制 真":state.状态_是否禁止录制 = Trueelif message[:5] == "录制的脚本":state.录制_脚本文本 = message[6:]#保存文件if state.录制_脚本文本 != "":logger.info(state.录制_脚本文本)with open("1111.txt", "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)logger.info("录制完毕!")finally:# 客户端断开连接后，将其移出集合connected_clients.remove(websocket)async def server_main():server = await websockets.serve(handle_client, "localhost", 29943, max_size=1024 * 1024 * 10)#添加下面这个#运行插件服务import subprocesstry:time.sleep(5)# 启动exe程序subprocess.Popen('"' + "./datas/jiaoben/xxx.exe" + '" "' + "29943" + '"')print("插件服务已经启动!")except:print("文件没找到可以能被杀毒软件干掉了 " + "./datas/jiaoben/xxx.exe")try:await asyncio.gather(server.wait_closed())except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")def send_msg(msg="是否回放#@@#假"):'''给躺宝发送指令全部指令  :是否回放#@@#假  /真是否暂停#@@#假  /真是否开始录制#@@#假 /真是否禁止录制#@@#假 /真解析脚本#@@#jiaoben"  jiaoben就是录制的脚本文本 不是文件 是直接文字全局hwnd#@@#12345   12345就是游戏的窗口句柄:param msg: 指令 用 #@@# 分割:return:'''logger.info("请求对插件客户端发送请求： "+ msg)asyncio.run_coroutine_threadsafe(send_to_client(-1, msg), loop)async def send_to_client(client_id, message):if len(connected_clients) > 0:# 查找指定的客户端await connected_clients[client_id].send(message)import asyncio# 创建一个新的事件循环
loop = asyncio.new_event_loop()#以协程非主进程形式运行
t = threading.Thread(target=loop.run_until_complete, args=(server_main(),))#协程以守护进程运行
python_var = sys.version_info[1]
if python_var > 8:t.daemon = True
else:t.setDaemon(True)
t.start()# print("服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出")
# print("这个程序将在未来作为一个协程启动，而非主进程形式")
# print("没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭")# input("回车退出")

 返回

服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出
这个程序将在未来作为一个协程启动，而非主进程形式
没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭
回车退出插件服务已经启动!
收到消息：是否禁止录制 真

因为我们是从外部调用事件循环，我们要先将服务端中的那个input主进程去掉

print("服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出")
print("这个程序将在未来作为一个协程启动，而非主进程形式")
print("没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭")#input("回车退出")

11、模拟录制键鼠

from wss import *#打开插件的录制功能
input("###########是否开启禁止录制\n")
send_msg("是否禁止录制#@@#假")   #允许录制input("########回车开始录制\n")
send_msg("是否开始录制#@@#真")  #开始录制input("########回车结束录制\n")
send_msg("是否开始录制#@@#假")  #关闭录制
send_msg("是否禁止录制#@@#真")  #开启禁止

 第一次回车取消禁止录制，第二次回车开启录制功能，但需要在按一次F8去激活插件中的录制功能，再按一次F8停止录制并返回消息给服务端（这步可以反复操作）,第三次回车，关闭录制功能

 返回

C:\Users\Administrator\PycharmProjects\yolo8test\.venv\Scripts\python.exe C:\Users\Administrator\PycharmProjects\yolo8test\test\test.py 
服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出
这个程序将在未来作为一个协程启动，而非主进程形式
没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭
回车退出插件服务已经启动!
收到消息：是否禁止录制 真###########是否开启禁止录制2024-10-15 17:21:10,416 - LenRenAI - INFO - 请求对插件客户端发送请求： 是否禁止录制#@@#假
########回车开始录制
收到消息：是否禁止录制 假
收到消息：是否禁止录制 假2024-10-15 17:21:14,896 - LenRenAI - INFO - 请求对插件客户端发送请求： 是否开始录制#@@#真
2024-10-15 17:21:14,898 - LenRenAI - INFO - 请按F8结束录制
########回车结束录制
收到消息：是否开始录制 真
2024-10-15 17:21:15,189 - LenRenAI - INFO - 请按F8结束录制
收到消息：是否开始录制 真
收到消息：是否开始录制 假
收到消息：录制的脚本 ##测试脚本##
鼠标初始 413 935
等待键 0.0229151
等待鼠 0.02292892024-10-15 17:21:19,095 - LenRenAI - INFO - ##测试脚本##
鼠标初始 413 935
等待键 0.0229151
等待鼠 0.02292892024-10-15 17:21:19,095 - LenRenAI - INFO - 录制完毕!
收到消息：是否开始录制 真
2024-10-15 17:21:20,297 - LenRenAI - INFO - 请按F8结束录制
收到消息：是否开始录制 假
收到消息：录制的脚本 ##测试脚本##
鼠标初始 413 935
等待键 3.993411
等待鼠 3.9934232024-10-15 17:21:24,202 - LenRenAI - INFO - ##测试脚本##
鼠标初始 413 935
等待键 3.993411
等待鼠 3.9934232024-10-15 17:21:24,202 - LenRenAI - INFO - 录制完毕!
收到消息：是否开始录制 真
2024-10-15 17:21:33,517 - LenRenAI - INFO - 请按F8结束录制
收到消息：是否开始录制 假
收到消息：录制的脚本 ##测试脚本##
鼠标初始 625 914
等待鼠 1.1647663
鼠标 0 0 21316 55553 0
等待鼠 0.0002612
鼠标 0 0 21282 55553 0
等待鼠 0.0398962
鼠标 0 0 21248 55675 0
等待鼠 0.0604424
鼠标 0 0 21248 55735 0
等待鼠 0.0098287
鼠标 0 0 21282 55735 0
等待鼠 0.0251939
鼠标 0 0 21350 55675 0
等待鼠 0.0002929
鼠标 0 0 21486 55432 0
等待鼠 0.0195504
鼠标 0 0 21623 55189 0
等待鼠 0.4348741
鼠标 0 0 21657 55129 0
等待鼠 0.0148643
鼠标 0 0 21725 55007 0
等待鼠 0.0182851
鼠标 0 0 21760 55007 0
等待鼠 0.1272844
鼠标 1 1 21760 55007 0
等待鼠 0.0874505
鼠标 1 2 21760 55007 0
等待鼠 0.1222998
鼠标 0 0 21794 55007 0
等待键 3.3952953
等待鼠 1.27003472024-10-15 17:21:47,638 - LenRenAI - INFO - ##测试脚本##
鼠标初始 625 914
等待鼠 1.1647663
鼠标 0 0 21316 55553 0
等待鼠 0.0002612
鼠标 0 0 21282 55553 0
等待鼠 0.0398962
鼠标 0 0 21248 55675 0
等待鼠 0.0604424
鼠标 0 0 21248 55735 0
等待鼠 0.0098287
鼠标 0 0 21282 55735 0
等待鼠 0.0251939
鼠标 0 0 21350 55675 0
等待鼠 0.0002929
鼠标 0 0 21486 55432 0
等待鼠 0.0195504
鼠标 0 0 21623 55189 0
等待鼠 0.4348741
鼠标 0 0 21657 55129 0
等待鼠 0.0148643
鼠标 0 0 21725 55007 0
等待鼠 0.0182851
鼠标 0 0 21760 55007 0
等待鼠 0.1272844
鼠标 1 1 21760 55007 0
等待鼠 0.0874505
鼠标 1 2 21760 55007 0
等待鼠 0.1222998
鼠标 0 0 21794 55007 0
等待键 3.3952953
等待鼠 1.27003472024-10-15 17:21:47,639 - LenRenAI - INFO - 录制完毕!
收到消息：是否开始录制 真
2024-10-15 17:21:47,939 - LenRenAI - INFO - 请按F8结束录制收到消息：是否开始录制 假
收到消息：是否禁止录制 真
2024-10-15 17:22:08,845 - LenRenAI - INFO - 请求对插件客户端发送请求： 是否开始录制#@@#假
2024-10-15 17:22:08,847 - LenRenAI - INFO - 请求对插件客户端发送请求： 是否禁止录制#@@#真Process finished with exit code 0

操作记录

鼠标初始 625 914
等待鼠 1.1647663
鼠标 0 0 21316 55553 0
等待鼠 0.0002612
鼠标 0 0 21282 55553 0
等待鼠 0.0398962
鼠标 0 0 21248 55675 0
等待鼠 0.0604424
鼠标 0 0 21248 55735 0
等待鼠 0.0098287
鼠标 0 0 21282 55735 0
等待鼠 0.0251939
鼠标 0 0 21350 55675 0
等待鼠 0.0002929
鼠标 0 0 21486 55432 0
等待鼠 0.0195504
鼠标 0 0 21623 55189 0
等待鼠 0.4348741
鼠标 0 0 21657 55129 0
等待鼠 0.0148643
鼠标 0 0 21725 55007 0
等待鼠 0.0182851
鼠标 0 0 21760 55007 0
等待鼠 0.1272844
鼠标 1 1 21760 55007 0
等待鼠 0.0874505
鼠标 1 2 21760 55007 0
等待鼠 0.1222998
鼠标 0 0 21794 55007 0
等待键 3.3952953
等待鼠 1.2700347

12、键盘鼠标监听

上面使用者发现一个问题，我们好像无法观测他到底开没开始录制，按下F8没有任何提示，录制完成了也不知道从哪里整的，我们先做一个键盘按键监听器，监听我们确实按下按键并且开始录制了

# -*- coding: gbk -*-
import timefrom pynput import keyboarddef on_press(key):# 这里写处理按键的逻辑print(f'{key} pressed')if key == keyboard.Key.esc:  # 如果按下Esc键，则停止监听return Falsedef on_release(key):# 可选：处理按键释放的逻辑print(f'{key} released')# 使用上下文管理器来创建一个监听器
with keyboard.Listener(on_press=on_press,on_release=on_release) as listener:# 监听器在此范围内活动# 其他代码可以在这里执行print("现在开始监听键盘事件，请按Esc键退出。")try:# 无限循环，保持程序运行while True:time.sleep(1)except KeyboardInterrupt:# 捕获Ctrl+C中断信号print("\n用户中断了程序。")

13、添加监听

# -*- coding: gbk -*-
import time
from pynput import keyboard
import state  # 假设 state 模块已经定义并包含相关变量
from wss import send_msg  # 假设 wss 模块已经定义并包含 send_msg 函数# 检查按键
def on_press(key):global stop_listener  # 声明 stop_listener 为全局变量# 如果按下 Esc，则视为停止# print(f'{key} pressed')if key == keyboard.Key.esc:  # 如果按下Esc键，则设置停止标志send_msg("是否禁止录制#@@#真")  # 禁止录制录制send_msg("是否开始录制#@@#假")  # 关闭录制开关state.录制_脚本文本 = ""stop_listener = True  # 设置停止标志# 按键 F8if key == keyboard.Key.media_play_pause:# print(key)print("按下F8")if state.状态_是否开始录制 == False:print("录制中,再次按下F8关闭")send_msg("是否禁止录制#@@#假")  #取消禁止录制send_msg("是否开始录制#@@#真")  #允许开始录制hwnd = 47449172send_msg(f"全局hwnd#@@#{hwnd}")else:print("录制关闭")send_msg("是否禁止录制#@@#真")  # 禁止录制send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 初始化状态
send_msg("是否禁止录制#@@#真")  # 禁止录制
send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 使用上下文管理器来创建一个监听器
with keyboard.Listener(on_press=on_press,
) as listener:# 监听器在此范围内活动# 其他代码可以在这里执行print("现在开始监听键盘事件，请按Esc键退出。")# 判断是否停止循环stop_listener = Falsewhile not stop_listener :time.sleep(1)# print("正在监听...")#检查文本是否存在数据if state.录制_脚本文本 != "":# print(f"已经有数据：{state.录制_脚本文本 }")stop_listener = True# 当离开 with 块时，监听器会自动停止

14、修改监听为后台运行

我们后面是要给ui用的，这里将键盘按键监听改为线程模式运行

# -*- coding: gbk -*-
import time
from pynput import keyboard
import threading
import state  # 假设 state 模块已经定义并包含相关变量
from wss import send_msg  # 假设 wss 模块已经定义并包含 send_msg 函数# 初始化标志变量
stop_listener = False# 检查按键
def on_press(key):global stop_listener  # 声明 stop_listener 为全局变量# 如果按下 Esc，则视为停止if key == keyboard.Key.esc:  # 如果按下Esc键，则设置停止标志send_msg("是否禁止录制#@@#真")  # 禁止录制录制send_msg("是否开始录制#@@#假")  # 关闭录制开关state.录制_脚本文本 = ""stop_listener = True  # 设置停止标志# 按键 F8if key == keyboard.Key.media_play_pause:if state.状态_是否开始录制 == False:print("录制中,再次按下F8关闭")send_msg("是否禁止录制#@@#假")  # 取消禁止录制send_msg("是否开始录制#@@#真")  # 允许开始录制hwnd = 47449172send_msg(f"全局hwnd#@@#{hwnd}")else:print("录制关闭")send_msg("是否禁止录制#@@#真")  # 禁止录制send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 启动按键监听器
def start_keyboard_listener():global stop_listenerstop_listener = Falsedef handle_on_press(key):on_press(key)if stop_listener:listener.stop()# 使用上下文管理器来创建一个监听器with keyboard.Listener(on_press=handle_on_press) as listener:print("现在开始监听键盘事件，请按Esc键退出。")listener.join()  # 等待监听器结束# 启动监听器
def start_listener_thread():thread = threading.Thread(target=start_keyboard_listener)thread.start()return thread# 示例使用
if __name__ == "__main__":# 初始化状态send_msg("是否禁止录制#@@#真")  # 禁止录制send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 启动监听器线程listener_thread = start_listener_thread()# UI 主进程可以在这里继续运行while True:# UI 主进程逻辑time.sleep(1)if state.录制_脚本文本 != "":print(f"已经有数据：{state.录制_脚本文本}")break# 如果需要停止监听器# listener_thread.join()

15、服务端全量

import asyncio
import concurrent.futures
import os
import sys
import threading
import time
import websocketsimport state# 存储所有已连接的客户端
connected_clients = []#处理客户端请求
#处理客户端请求
from logger_module import logger
async def handle_client(websocket, path):global new_msgtry:# 发送连接成功消息await websocket.send("连接成功")# 添加新连接的客户端到集合中connected_clients.append(websocket)while True:# 接收客户端发送的消息message = await websocket.recv()new_msg = message# print(f"收到消息：{message}")# 处理接收到的消息if message == "是否回放中 真":state.状态_是否回放中 = Trueelif message == "是否回放中 假":state.状态_是否回放中 = Falseelif message == "是否暂停 真":state.状态_是否暂停 = Trueelif message == "是否暂停 假":state.状态_是否暂停 = Falseelif message == "是否开始录制 假":state.状态_是否开始录制 = Falseelif message == "是否开始录制 真":if state.状态_是否禁止录制 == False:logger.info("请按F8结束录制")# state.QT_信号.mysig_tishi.emit(f"请按F8结束录制")state.状态_是否开始录制 = Trueelif message == "是否禁止录制 假":state.状态_是否禁止录制 = Falseelif message == "是否禁止录制 真":state.状态_是否禁止录制 = Trueelif message[:5] == "录制的脚本":state.录制_脚本文本 = message[6:]#保存文件if state.录制_脚本文本 != "":logger.info(state.录制_脚本文本)with open("1111.txt", "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)logger.info("录制完毕!")finally:# 客户端断开连接后，将其移出集合connected_clients.remove(websocket)async def server_main():server = await websockets.serve(handle_client, "localhost", 29943, max_size=1024 * 1024 * 10)#添加下面这个#运行插件服务import subprocesstry:time.sleep(5)# 启动exe程序subprocess.Popen('"' + "./datas/jiaoben/xxx.exe" + '" "' + "29943" + '"')print("插件服务已经启动!")except:print("文件没找到可以能被杀毒软件干掉了 " + "./datas/jiaoben/xxx.exe")try:await asyncio.gather(server.wait_closed())except asyncio.CancelledError:print("WebSocket server was cancelled.")except Exception as e:print(f"An error occurred: {e}")def send_msg(msg="是否回放#@@#假"):'''给躺宝发送指令全部指令  :是否回放#@@#假  /真是否暂停#@@#假  /真是否开始录制#@@#假 /真是否禁止录制#@@#假 /真解析脚本#@@#jiaoben"  jiaoben就是录制的脚本文本 不是文件 是直接文字全局hwnd#@@#12345   12345就是游戏的窗口句柄:param msg: 指令 用 #@@# 分割:return:'''logger.info("请求对插件客户端发送请求： "+ msg)asyncio.run_coroutine_threadsafe(send_to_client(-1, msg), loop)async def send_to_client(client_id, message):if len(connected_clients) > 0:# 查找指定的客户端await connected_clients[client_id].send(message)import asyncio# 创建一个新的事件循环
loop = asyncio.new_event_loop()#以协程非主进程形式运行
t = threading.Thread(target=loop.run_until_complete, args=(server_main(),))#协程以守护进程运行
python_var = sys.version_info[1]
if python_var > 8:t.daemon = True
else:t.setDaemon(True)
t.start()# print("服务端协程已守护进程模式运行,下面的代码需要去运行其他的主进程, 如果没有进程则会退出")
# print("这个程序将在未来作为一个协程启动，而非主进程形式")
# print("没有前台进程的话直接跑的话，主进程会结束，当主进程结束时，守护进程也会关闭")# input("回车退出")

16、客户端全量

# -*- coding: gbk -*-
import os
import time
from pynput import keyboard
import threading
import state  # 假设 state 模块已经定义并包含相关变量
from  logger_module import logger
from wss import send_msg  # 假设 wss 模块已经定义并包含 send_msg 函数# 初始化标志变量
stop_listener = False# 检查按键
def on_press(key):global stop_listener  # 声明 stop_listener 为全局变量time.sleep(5)# 如果按下 Esc，则视为停止if key == keyboard.Key.esc:  # 如果按下Esc键，则设置停止标志send_msg("是否禁止录制#@@#真")  # 禁止录制录制send_msg("是否开始录制#@@#假")  # 关闭录制开关state.录制_脚本文本 = ""stop_listener = True  # 设置停止标志# 按键 F8if key == keyboard.Key.media_play_pause:if state.状态_是否开始录制 == False:print("录制中,再次按下F8关闭")send_msg("是否禁止录制#@@#假")  # 取消禁止录制send_msg("是否开始录制#@@#真")  # 允许开始录制send_msg(f"全局脚本名#@@#1111.txt")   #文件名称定义hwnd = 47449172send_msg(f"全局hwnd#@@#{hwnd}")elif state.状态_是否开始录制 == True:print("录制关闭")send_msg("是否禁止录制#@@#真")  # 禁止录制send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 启动按键监听器
def start_keyboard_listener():global stop_listenerstop_listener = Falsedef handle_on_press(key):on_press(key)if stop_listener:listener.stop()# 使用上下文管理器来创建一个监听器with keyboard.Listener(on_press=handle_on_press) as listener:print("现在开始监听键盘事件，请按Esc键退出。")listener.join()  # 等待监听器结束# 启动监听器
def start_listener_thread():thread = threading.Thread(target=start_keyboard_listener)thread.start()return thread# 示例使用
if __name__ == "__main__":# 初始化状态send_msg("是否禁止录制#@@#真")  # 禁止录制send_msg("是否开始录制#@@#假")  # 关闭的录制开关# 启动监听器线程listener_thread = start_listener_thread()# UI 主进程可以在这里继续运行while True:time.sleep(1)# 如果需要停止监听器# listener_thread.join()#脚本回放# if state.状态_是否回放中 == True:#     return# if not os.path.exists(state.PATH_JIAOBEN):#     os.makedirs(state.PATH_JIAOBEN)# state.状态_是否回放中 = True# state.状态_循环开关 = True# jiaoben = os.path.abspath(os.path.join(state.PATH_JIAOBEN,state.LIANZHAO ))# message = f"解析脚本#@@#{jiaoben}"# tangbaowss.send_msg(message)# hwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄# set_window_activate(hwnd)# tangbaowss.send_msg("脚本执行#@@#1")# self.timer_huifang.start(200)

未完

4、初始化触发

以下4个定时器会周期性的去采集和回放键鼠操作

class MainWindow(QMainWindow, Ui_mainWindow):def __init__(self):。。。#4个定时器，周期进行录制和回放self.timer_luzhi = QTimer(self)self.timer_luzhi.timeout.connect(self.timeout_luzhi)self.timer_luzhi_chuansong = QTimer(self)self.timer_luzhi_chuansong.timeout.connect(self.timeout_luzhi_chuansong)self.timer_luzhi_lianzhao = QTimer(self)self.timer_luzhi_lianzhao.timeout.connect(self.timeout_luzhi_lianzhao)self.timer_huifang = QTimer(self)self.timer_huifang.timeout.connect(self.timeout_huifang)

5、定时器任务（录制、传送、连招函数、回放）

    def timeout_luzhi(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.join(state.PATH_TASK, self.datas[state.录制_当前任务索引]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = dir_ + "/脚本.txt"with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)self.datas[state.录制_当前任务索引]["jiaoben"] = "脚本.txt"self.datas[state.录制_当前任务索引]["f_item"].bt_jiaoben.setProperty("OK_jiaoben", True)print(f"导入脚本成功:{path}")self.sg.mysig_tishi.emit(f"导入脚本成功:{path}")self.datas[state.录制_当前任务索引]["f_item"].bt_jiaoben.setStyleSheet("""#bt_jiaoben[OK_jiaoben="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")state.录制_脚本文本 = ""self.save_ini(dir_, self.datas[state.录制_当前任务索引])self.timer_luzhi.stop()def timeout_luzhi_chuansong(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.join(state.PATH_TASK, self.datas[state.录制_当前任务索引]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = dir_ + "/传送脚本.txt"with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)self.datas[state.录制_当前任务索引]["chuansong"] = "传送脚本.txt"self.datas[state.录制_当前任务索引]["f_item"].bt_chuansong.setProperty("OK_chuansong", True)print(f"导入脚本成功:{path}")self.sg.mysig_tishi.emit(f"导入脚本成功:{path}")self.datas[state.录制_当前任务索引]["f_item"].bt_chuansong.setStyleSheet("""#bt_chuansong[OK_chuansong="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")state.录制_脚本文本 = ""self.save_ini(dir_, self.datas[state.录制_当前任务索引])self.timer_luzhi_chuansong.stop()def timeout_luzhi_lianzhao(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.abspath(state.PATH_JIAOBEN)if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = os.path.join(dir_, state.LIANZHAO)with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)state.录制_脚本文本 = ""print("录制并选择连招脚本成功!")self.sg.mysig_tishi.emit("录制并选择连招脚本成功!")self.save_ini_seting()self.timer_luzhi_lianzhao.stop()def timeout_huifang(self):if state.状态_循环开关 == False:state.状态_需重新传送 = Falsetangbaowss.send_msg("是否回放#@@#假")print("回放结束1")self.sg.mysig_tishi.emit("回放结束1")self.timer_huifang.stop()returnif state.状态_是否回放中 == False:print("回放结束2")self.sg.mysig_tishi.emit("回放结束2")self.timer_huifang.stop()

说明

1. timeout_luzhi#这个函数会在定时器触发时执行，主要功能如下：#如果state.录制_脚本文本不为空，则表示有脚本需要保存。#禁止进一步录制（通过tangbaowss.send_msg("是否禁止录制#@@#真")）。#将脚本保存到指定目录下的脚本.txt文件中。#更新相关数据结构（如self.datas），并设置样式来标记脚本已成功导入。#清空state.录制_脚本文本。#停止定时器。2. timeout_luzhi_chuansong#这个函数与timeout_luzhi非常相似，但是它将脚本保存到了传送脚本.txt文件中，#并且更新的是self.datas中的"chuansong"字段。这表明它可能专门用于处理与“传送”相关的脚本。3. timeout_luzhi_lianzhao#这个函数也是类似的功能，但是它将脚本保存到了state.LIANZHAO指定的文件名中#并且保存到了state.PATH_JIAOBEN目录下。这表明它可能用于处理与“连招”相关的脚本4. timeout_huifang#这个函数则处理回放结束的情况：#如果循环开关关闭，则发送“是否回放#@@#假”消息，表示停止回放。#更新状态，并发出提示信号。#如果回放状态变为False，则同样发送停止回放的消息，并停止定时器。5、小结这四个函数都是定时器触发的回调函数，它们共同作用于录制和回放的过程中。
具体来说：当录制完成时，定时器触发timeout_luzhi、timeout_luzhi_chuansong或timeout_luzhi_lianzhao之一，将录制的脚本保存到文件，并通知系统停止录制。当回放结束时，定时器触发timeout_huifang，通知系统停止回放，并发出相应的信号。这四个函数是整个系统的一部分，它们协同工作以确保录制的脚本能够正确保存，
并在回放结束后及时停止回放。这些函数通过定时器机制，
确保在适当的时候执行保存和停止操作，保证系统的稳定性和可靠性。

总的来说，在我们程序开始执行的时候，他们就会去循环检测我们文件中关于是否开启还是关闭录制、回放、传送的对应变量，如果发生变化就对我们上面的插件发送信号

小结 基本流程
具体步骤启动服务端：Python脚本启动WebSocket服务器，并监听一个端口。服务器准备好接收客户端连接，并处理来自客户端的消息。启动客户端（外部程序）：Python脚本通过subprocess.Popen启动外部程序，并传入WebSocket服务器的端口号。外部程序连接到WebSocket服务器，并监听服务器的消息。状态变化检测：定时器定期检查状态变量。如果检测到状态变化（例如录制完成、回放结束等），则执行相应的逻辑（如保存脚本、停止录制等）。发送信号：定时器会调用tangbaowss.send_msg()函数，向WebSocket服务器发送消息。例如，“是否禁止录制#@@#真”、“是否回放#@@#假”等。处理消息：WebSocket服务器接收到消息后，会根据消息内容更新状态变量。这些状态更新可能会触发进一步的动作（例如，通知外部程序停止录制）。

6、添加菜单（文件--录制）

connect_set 函数是我们前面用来做菜单栏的函数，还是在这里整

    #绑定信号槽def connect_set(self):self.sg = MySignal()state.QT_信号 = self.sg  #存储本地变量，允许其他函数查询并发送self.menu = self.menuBar()# 创建一个顶级菜单self.menu_file = self.menu.addMenu("文件")self.action_addlianzhao = QAction("录制/编辑连招", self)self.action_addlianzhao.triggered.connect(self.hotkey_addlianzhao)self.menu_file.addAction(self.action_addlianzhao)。。。#添加录制函数def hotkey_addlianzhao(self):# 弹出一个选择弹窗 选项为  录制还是文件中选择msgBox = QMessageBox(self)msgBox.setWindowTitle("配置连招")  # 设置消息框标题msgBox.setIcon(QMessageBox.Information)msgBox.setText("当前连招:" + state.LIANZHAO + "\n请选择一个配置方式:")msgBox.addButton("录制", QMessageBox.AcceptRole)msgBox.addButton("回放", QMessageBox.ApplyRole)msgBox.addButton("文件中选择", QMessageBox.RejectRole)result = msgBox.exec_()if result == QMessageBox.AcceptRole:try:text, ok = QInputDialog.getText(self, '提示', '请输入脚本名:', text=state.LIANZHAO)if not ok:returnif text == "":returnelif text[-4:] != ".txt":state.LIANZHAO = text + ".txt"else:state.LIANZHAO = textprint("可以开始录制了,按F8开始/停止")self.sg.mysig_tishi.emit("可以开始录制了,按F8开始/停止")state.状态_是否禁止录制 = Falsestate.状态_是否开始录制 = Falsestate.录制_脚本文本 = ""tangbaowss.send_msg("是否禁止录制#@@#假")tangbaowss.send_msg("是否开始录制#@@#假")tangbaowss.send_msg(f"全局脚本名#@@#{state.LIANZHAO.replace('.txt', '')}")hwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄tangbaowss.send_msg(f"全局hwnd#@@#{hwnd}")self.timer_luzhi_lianzhao.start(200)except:passelif result == QMessageBox.RejectRole:if state.状态_是否回放中 == True:returnif not os.path.exists(state.PATH_JIAOBEN):os.makedirs(state.PATH_JIAOBEN)state.状态_是否回放中 = Truestate.状态_循环开关 = Truejiaoben = os.path.abspath(os.path.join(state.PATH_JIAOBEN, state.LIANZHAO))message = f"解析脚本#@@#{jiaoben}"tangbaowss.send_msg(message)hwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄set_window_activate(hwnd)tangbaowss.send_msg("脚本执行#@@#1")self.timer_huifang.start(200)elif result == QMessageBox.Warning:self.hotkey_setlianzhao()def hotkey_setlianzhao(self):# 弹出一个有分组框的窗口temp_path, ok = QFileDialog.getOpenFileName(self, "连招脚本", state.PATH_JIAOBEN, "脚本文件 (*.txt)")if ok:_, state.LIANZHAO = os.path.split(temp_path)dir_ = os.path.join(state.PATH_JIAOBEN, state.LIANZHAO)try:shutil.copy(temp_path, dir_)except:passprint("选择连招脚本成功!")self.save_ini_seting()def hotkey_setlianzhao(self):# 弹出一个有分组框的窗口temp_path, ok = QFileDialog.getOpenFileName(self, "连招脚本", state.PATH_JIAOBEN, "脚本文件 (*.txt)")if ok:_, state.LIANZHAO = os.path.split(temp_path)dir_ = os.path.join(state.PATH_JIAOBEN, state.LIANZHAO)try:shutil.copy(temp_path, dir_)except:passprint("选择连招脚本成功!")self.save_ini_seting()

注意，这里有个set_window_activate(hwnd)的函数是我们之前的代码moni中带的强制激活窗口，这里单开的案例应该是没有的。

7、新增信号

class MySignal(QObject):mySignal = pyqtSignal(int, str)  # 定义自定义信号，并指定信号参数类型mysig_shutdown = pyqtSignal()mysig_mouse_through = pyqtSignal(bool)mysig_tishi = pyqtSignal(str)mysig_show_xunlu = pyqtSignal()mysig_show_yolov = pyqtSignal()mysig_dingwei=pyqtSignal(int)mysig_next_pack=pyqtSignal()

8、全量代码

import configparser
import ctypes
import functools
import os
import re
import shutil
import subprocess
import sys
import threading
import timeimport win32gui
# 导入PyQt5模块
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *import state
import tangbaowss
from demo1.lanrenauto.moni.moni import set_window_activate
# 导入UI文件生成的类
from ui.show import Ui_DockWidget
from ui.main import Ui_mainWindow
from ui.formpy import Ui_formpydef extract_number(folder_name):numbers = re.findall(r'\d+', folder_name)return int(numbers[0]) if numbers else float('inf')class FramePY(QFrame, Ui_formpy):def __init__(self, parent=None):super(QFrame, self).__init__(parent)self.setupUi(self)self.set_ui()self.is_zd = Falsew = int(item_width * ratio)h = int(item_height_min * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)# self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint | Qt.WindowStaysOnTopHint)def set_ui(self):passdef mousePressEvent(self, event):if not self.is_zd:self.is_zd = not self.is_zdw = int(item_width * ratio)h = int(item_height * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)self.bt_arg.setVisible(True)self.bt_opendir.setVisible(True)self.bt_chuansong.setVisible(True)self.bt_moban.setVisible(True)self.bt_moban_maodian.setVisible(True)self.bt_start.setVisible(True)self.bt_del.setVisible(True)else:self.is_zd = not self.is_zdw = int(item_width * ratio)h = int(item_height_min * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)self.bt_arg.setVisible(False)self.bt_opendir.setVisible(False)self.bt_chuansong.setVisible(False)self.bt_moban.setVisible(False)self.bt_moban_maodian.setVisible(False)self.bt_start.setVisible(False)self.bt_del.setVisible(False)class MySignal(QObject):mysig_show_xunlu = pyqtSignal()mysig_show_yolov = pyqtSignal()mySignal = pyqtSignal(int, str)  # 定义自定义信号，并指定信号参数类型mysig_shutdown = pyqtSignal()mysig_mouse_through = pyqtSignal(bool)mysig_tishi = pyqtSignal(str)mysig_dingwei=pyqtSignal(int)mysig_next_pack=pyqtSignal()# 定义FormShow类，继承自QDockWidget和Ui_DockWidget
class FormShow(QDockWidget, Ui_DockWidget):def __init__(self, parent=None):super(QDockWidget, self).__init__(parent)  # 调用父类构造函数self.parent = parent  # 保存父窗口引用self.setParent(parent)  # 设置父窗口self.setupUi(self)  # 初始化UI界面self.set_ui()  # 自定义设置UI界面# 设置窗口标题self.setWindowTitle("检测预览")# 设置标签控件属性self.lb_yolov.setScaledContents(True)self.lb_yolov.setAlignment(Qt.AlignCenter)self.lb_xunlu.setAlignment(Qt.AlignCenter)# 移动窗口位置self.move(0, 0)# 设置窗口保持在最顶层self.setWindowFlags(Qt.WindowStaysOnTopHint)# 计算窗口大小self.window_height = int(270 * ratio)self.window_width = int(480 * ratio)# 设置窗口最小尺寸self.setMinimumSize(self.window_width, self.window_height * 2)# 连接按钮点击事件self.bt_jia.clicked.connect(self.clicked_jia)self.bt_jian.clicked.connect(self.clicked_jian)# 自定义UI设置def set_ui(self):pass  # 此处可添加更多UI设置# 按钮“加”点击事件处理def clicked_jia(self):# 如果窗口高度加上增量后超过屏幕高度，则返回if self.window_height + 108 * ratio > 1080 * ratio:return# 更新窗口大小self.window_height += int(108 * ratio)self.window_width += int(190 * ratio)# 设置标签固定高度self.lb_xunlu.setFixedHeight(self.window_height)# 根据窗口宽度调整标签位置if self.width() >= self.lb_yolov.width() + self.lb_xunlu.width():self.lb_yolov.move(self.lb_xunlu.width(), 0)else:self.lb_yolov.move(0, self.lb_xunlu.height())# 设置标签固定大小self.lb_yolov.setFixedHeight(self.window_height)self.lb_yolov.setFixedWidth(self.window_width)# 按钮“减”点击事件处理def clicked_jian(self):# 如果窗口高度减去增量后小于最小高度，则返回if self.window_height - 108 * ratio < 270 * ratio:return# 更新窗口大小self.window_height -= int(108 * ratio)self.window_width -= int(190 * ratio)# 设置标签固定高度self.lb_xunlu.setFixedHeight(self.window_height)# 根据窗口宽度调整标签位置if self.width() >= self.lb_yolov.width() + self.lb_xunlu.width():self.lb_yolov.move(self.lb_xunlu.width(), 0)else:self.lb_yolov.move(0, self.lb_xunlu.height())# 设置标签固定大小self.lb_yolov.setFixedHeight(self.window_height)self.lb_yolov.setFixedWidth(self.window_width)# 重写关闭事件def closeEvent(self, event):# 关闭窗口时取消主窗口上的动作选中状态self.parent.action_isShow.setChecked(False)# 重写调整大小事件def resizeEvent(self, event):# 根据窗口宽度调整标签位置if self.width() >= self.lb_yolov.width() + self.lb_xunlu.width():self.lb_yolov.move(self.lb_xunlu.width(), 0)else:self.lb_yolov.move(0, self.lb_xunlu.height())# 定义MainWindow类，继承自QMainWindow和Ui_mainWindow
class MainWindow(QMainWindow, Ui_mainWindow):def __init__(self):super(MainWindow, self).__init__()  # 调用父类构造函数self.setupUi(self)  # 设置UI布局self.retranslateUi(self)  # 重新翻译UI组件的文字# 修改窗口样式为黑灰色，高亮self.set_ui()# 设置窗口标题self.setWindowTitle(f"修改主页标题")# 设置窗口尺寸self.resize(640, 900)# 设置窗口起始位置self.move(0, 300)# 创建网格布局self.g_box = QGridLayout()# 创建一个中间部件self.container_widget = QWidget()# 将网格布局设置给中间部件self.container_widget.setLayout(self.g_box)# 设置布局左上对齐self.g_box.setAlignment(Qt.AlignTop | Qt.AlignLeft)# 设置布局边距self.g_box.setContentsMargins(0, 0, 0, 0)# 设置布局左对齐self.g_box.setAlignment(Qt.AlignTop)# 将中间部件设置为QScrollArea的子部件self.sa_main.setWidget(self.container_widget)# 获取纵向滚动条控件vertical_scrollbar = self.findChild(QScrollArea)self.v_scrollbar = vertical_scrollbar.verticalScrollBar()# 设置窗口保持在最顶层self.setWindowFlags(Qt.WindowStaysOnTopHint)# 初始化变量self.row = 0self.column = -1self.run_times = 1self.column_step = 310# 获取主窗口的状态栏对象self.statusbar = self.statusBar()# 设置状态栏文本self.statusbar.showMessage('欢迎使用')# 初始化数据列表self.datas = []# 创建一个计时器，用于延迟布局self.timer = QTimer(self)self.timer.setSingleShot(True)  # 设置为单次触发self.timer.timeout.connect(self.update_layout)# 绑定信号槽self.connect_set()# 创建定时器  用于周期显示图片self.timer = QTimer(self)self.timer.timeout.connect(self.on_timer_timeout)self.timer.start(5000)  # 每5秒触发一次# 添加任务包self.load_task_packs()#显示默认的任务self.show_tool_item(state.PATH_TASK)self.timer_luzhi = QTimer(self)self.timer_luzhi.timeout.connect(self.timeout_luzhi)self.timer_luzhi_chuansong = QTimer(self)self.timer_luzhi_chuansong.timeout.connect(self.timeout_luzhi_chuansong)self.timer_luzhi_lianzhao = QTimer(self)self.timer_luzhi_lianzhao.timeout.connect(self.timeout_luzhi_lianzhao)self.timer_huifang = QTimer(self)self.timer_huifang.timeout.connect(self.timeout_huifang)def load_task_packs(self):self.toolBar.clear()packs = state.PACKS_TASK.split("#@@#")try:if len(packs) >= 1:for pack in packs:if pack != "":self.add_tool_item(pack)else:self.add_tool_item(state.PACKS_TASK)except:passdef add_tool_item(self, dir_):action_item = QWidgetAction(self)dir_ = dir_.replace("/", "\\")if dir_[-1] == "\\":dir_ = dir_[:-1]# 这里把路径下的目录名取出来当作按钮名称bt_item = QPushButton(dir_.split("\\")[-1].strip())bt_item.setMaximumWidth(int(80 * ratio))# 读取项目的说明打印出来try:with open(dir_ + "/" + "使用说明.txt", "r", encoding="utf-8") as f:txt = f.read()except:try:with open(dir_ + "/" + "使用说明.txt", "r", encoding="utf-8") as f:txt = f.read()except:txt = "无  \n(可以在任务包文件夹下创建一个 使用说明.txt 文件 来添加说明)"bt_item.setToolTip(dir_ + "\n使用说明:" + txt + "\n")bt_item.setStyleSheet("border: none; padding: 3px;")# 绑定按钮的功能bt_item.clicked.connect(functools.partial(self.show_tool_item, dir_))# 添加动作action_item.setDefaultWidget(bt_item)# 按钮添加到工具栏self.toolBar.addAction(action_item)menu = QMenu(self)action_menu_down = QAction('顺序 ↓', self)action_menu_down.triggered.connect(functools.partial(self.down_tool_item, len(self.toolBar.actions())))menu.addAction(action_menu_down)action_menu_up = QAction('顺序 ↑', self)action_menu_up.triggered.connect(functools.partial(self.up_tool_item, len(self.toolBar.actions())))menu.addAction(action_menu_up)action_menu_del = QAction('删除任务包', self)action_menu_del.triggered.connect(functools.partial(self.del_tool_item, action_item, bt_item, dir_))menu.addAction(action_menu_del)# 将菜单关联到工具栏上bt_item.setContextMenuPolicy(Qt.CustomContextMenu)bt_item.customContextMenuRequested.connect(lambda pos: menu.exec_(bt_item.mapToGlobal(pos)))self.change_tool_show_style(dir_)def del_tool_item(self, action_item, bt_item, dir_):self.toolBar.removeAction(action_item)if state.PATH_TASK.replace("/", "\\") == dir_:self.datas = []self.row = 0self.column = -1# 清空当前布局for i in reversed(range(self.g_box.count())):self.g_box.itemAt(i).widget().setParent(None)del bt_item, action_item  # 删除动作对象和bt对象txt_ = ""packs = state.PACKS_TASK.split("#@@#")if len(packs) >= 1:for pack in packs:if os.path.realpath(dir_) != os.path.realpath(pack) and pack != "":txt_ = txt_ + pack + "#@@#"state.PACKS_TASK = txt_print(f"成功移除{dir_}任务包")self.sg.mysig_tishi.emit(f"成功移除{dir_}任务包")def down_tool_item(self, idex):task_list = state.PACKS_TASK.split("#@@#")if idex < len(task_list) - 1:# 将指定索引位置的成员与其前一个成员交换位置task_list[idex], task_list[idex + 1] = task_list[idex + 1], task_list[idex]state.PACKS_TASK = ""for item in task_list:if item != "":state.PACKS_TASK += "#@@#" + itemself.load_task_packs()def up_tool_item(self, idex):task_list = state.PACKS_TASK.split("#@@#")if idex > 0:# 将指定索引位置的成员与其后一个成员交换位置task_list[idex], task_list[idex - 1] = task_list[idex - 1], task_list[idex]state.PACKS_TASK = ""for item in task_list:if item != "":state.PACKS_TASK += "#@@#" + itemself.load_task_packs()def save_ini_seting(self):try:hwnd = ctypes.windll.kernel32.GetConsoleWindow()if hwnd:rect = win32gui.GetWindowRect(hwnd)x, y, w, h = rect[0], rect[1], rect[2] - rect[0], rect[3] - rect[1]else:x, y, w, h = state.CMD_LEFT, state.CMD_TOP, state.CMD_WIDTH, state.CMD_HEIGHT# 创建 ConfigParser 对象config = configparser.ConfigParser()# 添加节和键-值对config['seting'] = {"GAME_TITLE": state.GAME_TITLE,'LIANZHAO': state.LIANZHAO,'LIANZHAOFUWU': state.LIANZHAOFUWU,'DUANGKOUHAO': state.DUANGKOUHAO,'PATH_TASK': state.PATH_TASK,'PATH_JIAOBEN': state.PATH_JIAOBEN,'PACKS_TASK': state.PACKS_TASK,'WEIGHTS': state.WEIGHTS,'PROVIDERS': state.PROVIDERS,'IMGSIZE_WIDTH': str(state.IMGSIZE_WIDTH),'IMGSIZE_HEIGHT': str(state.IMGSIZE_HEIGHT),'WINDOW_WIDTH': str(self.width()),'WINDOW_HEIGHT': str(self.height()),'WINDOW_LEFT': str(self.x()),'WINDOW_TOP': str(self.y()),'CMD_WIDTH': str(w),'CMD_HEIGHT': str(h),'CMD_LEFT': str(x),'CMD_TOP': str(y),'ON_SHUTDOWN': str(state.ON_SHUTDOWN),'ON_JIXING': str(state.ON_JIXING),'ON_NEXTPACK': str(state.ON_NEXTPACK),'ON_STARTWITH': str(state.ON_STARTWITH),'ON_LIANZHAOBUJIANCE': str(state.ON_LIANZHAOBUJIANCE),'TIMEOUT_DAGUAI': str(state.TIMEOUT_DAGUAI)}# 写入配置到 INI 文件with open("./datas/setting.ini", 'w') as configfile:config.write(configfile)except:passdef change_tool_show_style(self, dir_):# 获取工具栏上的所有动作actions_list = self.toolBar.actions()# 遍历处理每个动作for action in actions_list:# 在这里对每个动作进行处理bt_item = action.defaultWidget()if dir_ == bt_item.toolTip().replace("/", "\\").split("\n")[0]:bt_item.setStyleSheet("border-width: 1px; padding: 3px;")else:bt_item.setStyleSheet("border: none; padding: 3px;")def show_tool_item(self, dir_):self.save()state.PATH_TASK = dir_self.save_ini_seting()#self.update_tasks()   不知道为什么作者在这里又写了一遍，先注释了#self.change_tool_show_style(dir_)print(f"成功设置{state.PATH_TASK}为当前任务文件夹")def timeout_luzhi(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.join(state.PATH_TASK, self.datas[state.录制_当前任务索引]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = dir_ + "/脚本.txt"with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)self.datas[state.录制_当前任务索引]["jiaoben"] = "脚本.txt"self.datas[state.录制_当前任务索引]["f_item"].bt_jiaoben.setProperty("OK_jiaoben", True)print(f"导入脚本成功:{path}")self.sg.mysig_tishi.emit(f"导入脚本成功:{path}")self.datas[state.录制_当前任务索引]["f_item"].bt_jiaoben.setStyleSheet("""#bt_jiaoben[OK_jiaoben="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")state.录制_脚本文本 = ""self.save_ini(dir_, self.datas[state.录制_当前任务索引])self.timer_luzhi.stop()def timeout_luzhi_chuansong(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.join(state.PATH_TASK, self.datas[state.录制_当前任务索引]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = dir_ + "/传送脚本.txt"with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)self.datas[state.录制_当前任务索引]["chuansong"] = "传送脚本.txt"self.datas[state.录制_当前任务索引]["f_item"].bt_chuansong.setProperty("OK_chuansong", True)print(f"导入脚本成功:{path}")self.sg.mysig_tishi.emit(f"导入脚本成功:{path}")self.datas[state.录制_当前任务索引]["f_item"].bt_chuansong.setStyleSheet("""#bt_chuansong[OK_chuansong="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")state.录制_脚本文本 = ""self.save_ini(dir_, self.datas[state.录制_当前任务索引])self.timer_luzhi_chuansong.stop()def timeout_luzhi_lianzhao(self):if state.录制_脚本文本 != "":tangbaowss.send_msg("是否禁止录制#@@#真")state.状态_是否禁止录制 = Truedir_ = os.path.abspath(state.PATH_JIAOBEN)if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成path = os.path.join(dir_, state.LIANZHAO)with open(path, "w", encoding="gbk", newline='') as f:f.write(state.录制_脚本文本)state.录制_脚本文本 = ""print("录制并选择连招脚本成功!")self.sg.mysig_tishi.emit("录制并选择连招脚本成功!")self.save_ini_seting()self.timer_luzhi_lianzhao.stop()def timeout_huifang(self):if state.状态_循环开关 == False:state.状态_需重新传送 = Falsetangbaowss.send_msg("是否回放#@@#假")print("回放结束1")self.sg.mysig_tishi.emit("回放结束1")self.timer_huifang.stop()returnif state.状态_是否回放中 == False:print("回放结束2")self.sg.mysig_tishi.emit("回放结束2")self.timer_huifang.stop()def save(self):for idex in range(len(self.datas)):self.returnPressed_name(idex)# 重写closeEvent方法，在窗口关闭时调用quit()退出应用程序for i, data in enumerate(self.datas):dir_ = os.path.join(state.PATH_TASK, data["name"])self.save_ini(dir_, data)self.update_tasks()self.save_ini_seting()def update_tasks(self):try:self.datas = []self.row = 0self.column = -1# 清空当前布局for i in reversed(range(self.g_box.count())):self.g_box.itemAt(i).widget().setParent(None)# 遍历文件夹下有哪些目录# 判断这个路径是否存在if not os.path.exists(state.PATH_TASK):state.PATH_TASK = "./datas/Task/"# 创建 ConfigParser 对象config_main = configparser.ConfigParser()# 加载 INI 文件config_main.read(os.path.join(state.PATH_TASK, "细节参数.ini"))self.run_times = int(config_main.get('seting', 'run_times', fallback='1'))self.action_run_times.setText(f"设置:当前任务包 执行次数:{self.run_times}")# 获取文件夹列表folders = [item for item in os.listdir(state.PATH_TASK) ifos.path.isdir(os.path.join(state.PATH_TASK, item))]print(folders)# 将文件夹名称中的数字提取出来，并按照数字大小排序sorted_folders = sorted(folders, key=lambda x: extract_number(x))for item in sorted_folders:item_path = os.path.join(state.PATH_TASK, item)if os.path.isdir(item_path):# 创建 ConfigParser 对象config = configparser.ConfigParser()# 加载 INI 文件config.read(os.path.join(item_path, "jiaoben.ini"))if config.get('seting', 'type', fallback='1') == "2":# 副本任务# self.add_taskfuben(item_path, config)passelif config.get('seting', 'type', fallback='1') == "3":# 脚本任务# self.add_taskjiaoben(item_path, config)passelif config.get('seting', 'type', fallback='1') == "4":# 脚本任务# self.add_xuanjue(item_path, config)passelif config.get('seting', 'type', fallback='1') == "5":# 脚本任务# self.add_xuanlianzhao(item_path, config)passelif config.get('seting', 'type', fallback='1') == "6":self.add_taskpy(item_path, config)else:# 锄地任务# self.add_task(item_path, config)passexcept Exception:print(f"请选择任务文件夹,目前没有这个文件夹{state.PATH_TASK}")def add_taskpy(self, dir_, config):'''添加任务:return:'''# 根据导入的文件# 获取主窗口的宽度width = self.centralWidget().width()# 计算每行可以容纳的组件数量num_per_row = (width) // (self.column_step * ratio)  # 假设每个组件的宽度为200if num_per_row < 1:num_per_row = 1self.column += 1if self.column == num_per_row:self.column = 0self.row += 1# 加载ini配置文件f_item = FramePY()f_item.setObjectName("frame_cont")f_item.raise_()f_item.setStyleSheet("""#frame_cont:hover {border: 1px solid red;}#frame_cont {background-color: rgba(0, 0, 0, 0);}""")d = {}dir_ = dir_.replace("/", "\\")if dir_[-1] == "\\":dir_ = dir_[:-1]d["type"] = "6"try:config.set('seting', 'name', dir_.split("\\")[-1].strip())except:# 添加一个名为 'seting' 的配置节config.add_section('seting')config.set('seting', 'name', dir_.split("\\")[-1].strip())d["name"] = config.get('seting', 'name', fallback=dir_.split("\\")[-1]).strip()d["arg"] = config.get('seting', 'arg', fallback=dir_ + "\\参数.ini")d["opendir"] = config.get('seting', 'opendir', fallback=dir_)d["chuansong"] = config.get('seting', 'chuansong', fallback='')d["chuansongmoban"] = config.get('seting', 'chuansongmoban', fallback='')d["maodianmoban"] = config.get('seting', 'maodianmoban', fallback='')d["cb_is_checked"] = config.get('seting', 'cb_is_checked', fallback='True')d["cbb_address"] = config.get('seting', 'cbb_address', fallback='手动录制')d["cb_wakuang"] = config.get('seting', 'cb_wakuang', fallback='False')d["cb_caiji"] = config.get('seting', 'cb_caiji', fallback='False')d["cb_daguai"] = config.get('seting', 'cb_daguai', fallback='True')f_item.bt_chuansong.setProperty("OK_chuansong", d["chuansong"] != "")f_item.bt_moban.setProperty("OK_chuansongmoban", d["chuansongmoban"] != "")f_item.bt_moban_maodian.setProperty("OK_maodianmoban", d["maodianmoban"] != "")f_item.bt_chuansong.setObjectName("bt_chuansong")f_item.bt_moban.setObjectName("bt_moban")f_item.bt_moban_maodian.setObjectName("bt_moban_maodian")f_item.led_name.setText(d["name"])f_item.bt_arg.setStyleSheet("""color: rgb(237,182,43);  border-color: rgb(237,182,43); """)f_item.bt_opendir.setStyleSheet("""color: rgb(237,182,43);  border-color: rgb(237,182,43); """)f_item.bt_chuansong.setStyleSheet("""#bt_chuansong[OK_chuansong="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")f_item.bt_moban.setStyleSheet("""#bt_moban[OK_chuansongmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")f_item.bt_moban_maodian.setStyleSheet("""#bt_moban_maodian[OK_maodianmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")if d["cb_is_checked"] == "True":f_item.cb_is_checked.setChecked(True)else:f_item.cb_is_checked.setChecked(False)idex = len(self.datas)# f_item.led_name.editingFinished.connect(self.save)f_item.bt_arg.clicked.connect(lambda: subprocess.Popen(['notepad.exe', d["arg"]]))f_item.bt_opendir.clicked.connect(lambda: subprocess.Popen(['explorer', d["opendir"]]))f_item.bt_chuansong.clicked.connect(functools.partial(self.clickd_bt_chuansong, idex))f_item.bt_moban.clicked.connect(functools.partial(self.clickd_bt_moban, idex))f_item.bt_moban_maodian.clicked.connect(functools.partial(self.clickd_bt_moban_maodian, idex))f_item.bt_start.clicked.connect(functools.partial(self.clickd_bt_start, idex))f_item.bt_del.clicked.connect(functools.partial(self.clickd_bt_del, idex))f_item.bt_arg.setVisible(False)f_item.bt_opendir.setVisible(False)f_item.bt_chuansong.setVisible(False)f_item.bt_moban.setVisible(False)f_item.bt_moban_maodian.setVisible(False)f_item.bt_start.setVisible(False)f_item.bt_del.setVisible(False)f_item.bt_moban.setToolTip(self.tanChu_img(dir_ + "/" + d["chuansongmoban"]))f_item.bt_moban_maodian.setToolTip(self.tanChu_img(dir_ + "/" + d["maodianmoban"]))d["f_item"] = f_itemself.datas.append(d)self.g_box.addWidget(f_item, self.row, self.column)# 将py模板文件复制一份dir_py = os.path.join(d['opendir'], 'main.py')dir_ini = os.path.join(d['opendir'], '参数.ini')try:if not os.path.exists(dir_py):shutil.copy('datas/pymode.py', dir_py)if not os.path.exists(dir_ini):shutil.copy('datas/pymode.ini', dir_ini)except:passdef tanChu_img(self, imgpath):'''弹出图片:param imgpath::return:'''# ----------------------try:return f'''<img src='{imgpath}' > '''except Exception as err:return str(err)def clickd_bt_chuansong(self, idex):# dl_chuansong = DialogChuansong(self, idex)# dl_chuansong.cbb_address.setCurrentText(self.datas[idex]['cbb_address'])# dl_chuansong.exec_()passdef clickd_bt_moban(self, idex):temp_path, ok = QFileDialog.getOpenFileName(self, "传送模板图片", "", "图片文件 (*.png)")if ok:dir_ = os.path.join(state.PATH_TASK, self.datas[idex]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成# 将图片复制到指定目录path = dir_ + "/传送模板.png"shutil.copy(temp_path, path)self.datas[idex]["chuansongmoban"] = "传送模板.png"self.datas[idex]["f_item"].bt_moban.setProperty("OK_chuansongmoban", True)self.datas[idex]["f_item"].bt_moban.setStyleSheet("""#bt_moban[OK_chuansongmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")self.save_ini(dir_, self.datas[idex])self.sg.mysig_tishi.emit(f"导入传送模板成功:{path}")print(f"导入传送模板成功:{path}")def clickd_bt_moban_maodian(self, idex):temp_path, ok = QFileDialog.getOpenFileName(self, "锚点模板图片", "", "图片文件 (*.png)")if ok:dir_ = os.path.join(state.PATH_TASK, self.datas[idex]["name"])if not os.path.exists(dir_):os.makedirs(dir_)# 并且将jiaoben.ini文件也填入数据然后生成# 将图片复制到指定目录path = dir_ + "/锚点模板.png"shutil.copy(temp_path, path)self.datas[idex]["maodianmoban"] = "锚点模板.png"self.datas[idex]["f_item"].bt_moban_maodian.setProperty("OK_maodianmoban", True)self.datas[idex]["f_item"].bt_moban_maodian.setStyleSheet("""#bt_moban_maodian[OK_maodianmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")self.save_ini(dir_, self.datas[idex])print(f"导入锚点模板成功:{path}")self.sg.mysig_tishi.emit(f"导入锚点模板成功:{path}")def clickd_bt_start(self, idex):global ysylhwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄if hwnd == 0:print("错误:请先开游戏!")self.sg.mysig_tishi.emit("错误:请先开游戏!")returnleft, top, right, bottom = win32gui.GetClientRect(hwnd)width = right - leftheight = bottom - topif width != 1920 or height != 1080:print("错误:游戏分辨率不对!请确保游戏分辨率是1920x1080  建议重新设置分辨率")self.sg.mysig_tishi.emit("错误:游戏分辨率不对!请确保游戏分辨率是1920x1080  建议重新设置分辨率")returnself.save()def run(idex):ret = Falseself.sg.mysig_mouse_through.emit(True)state.计次_传送重试次数 = 0state.状态_全局暂停 = Falseself.datas[idex]['f_item'].cb_is_checked.setChecked(True)for rt in range(self.run_times):if self.action_runstartwith.isChecked():print(f"任务包:{state.PATH_TASK} {rt + 1}/{self.run_times}")while idex < len(self.datas):if state.状态_检测中:time.sleep(1)continueif self.datas[idex]['f_item'].cb_is_checked.isChecked():ret, arg = self.run(idex)if arg is None:arg = "0"if arg != "0":idex = self.arg_jisuan(arg, idex)if state.状态_循环开关 == False:breakif ret == False:if state.状态_需重新传送 == True:state.计次_传送重试次数 += 1if state.计次_传送重试次数 >= 5:state.计次_传送重试次数 = 0print("传送重试次数过多，放弃该任务!")else:print(f"传送重试{state.计次_传送重试次数}")time.sleep(2)continueelse:breakif self.action_runstartwith.isChecked() == False:breakstate.计次_传送重试次数 = 0idex += 1if self.action_runstartwith.isChecked() == False:breakif state.状态_循环开关 == False:breakidex = 0if state.状态_循环开关 != False:if self.action_runstartwith.isChecked():# 切下一个任务包 继续next_tas = self.get_next_task()if state.ON_NEXTPACK == 1 and next_tas != None:print("切下一个任务包!")state.PATH_TASK = next_tasself.sg.mysig_mouse_through.emit(False)self.sg.mysig_next_pack.emit()returnif ret == True and state.ON_JIXING == 1:ysyl.run_jixing()if ret == True and state.ON_SHUTDOWN == 1:self.sg.mysig_shutdown.emit()self.sg.mysig_mouse_through.emit(False)state.状态_循环开关 = Falset = threading.Thread(target=run, args=(idex,))if state.python_var > 9:t.daemon = Trueelse:t.setDaemon(True)t.start()def clickd_bt_del(self, idex):dir_ = os.path.join(state.PATH_TASK, self.datas[idex]["name"])try:# 删除整个文件夹shutil.rmtree(dir_)print(f"文件夹 {dir_} 已被删除")self.update_tasks()except Exception as e:self.update_tasks()print(f"删除文件夹时出现错误:{e}")def on_timer_timeout(self):# 每隔一段时间自动显示图片self.sg.mysig_show_xunlu.emit()self.sg.mysig_show_yolov.emit()# 绑定信号槽def connect_set(self):self.sg = MySignal()state.QT_信号 = self.sgself.menu = self.menuBar()# 创建一个顶级菜单self.menu_file = self.menu.addMenu("文件")self.action_addlianzhao = QAction("录制/编辑连招", self)self.action_addlianzhao.triggered.connect(self.hotkey_addlianzhao)self.menu_file.addAction(self.action_addlianzhao)# 创建一个顶级菜单self.menu = self.menuBar()self.menu_view = self.menu.addMenu("视图")# 创建一个动作self.action_isShow = QAction("显示检测结果窗口", self)self.action_isShow.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_F11))self.action_isShow.triggered.connect(self.hotkey_isShow)self.action_isShow.setCheckable(True)self.action_isShow.setChecked(True)self.menu_view.addAction(self.action_isShow)# 打开预测窗口self.hotkey_isShow()self.sg.mysig_show_xunlu.connect(self.show_xunlu)self.sg.mysig_show_yolov.connect(self.show_yolov)# 创建一个顶级菜单self.menu_run = self.menu.addMenu("操作")# 创建一个动作self.action_run_times = QAction(f"设置:当前任务包 执行次数:{self.run_times}", self)self.action_run_times.triggered.connect(self.hotkey_run_times)self.menu_run.addAction(self.action_run_times)def hotkey_addlianzhao(self):# 弹出一个选择弹窗 选项为  录制还是文件中选择msgBox = QMessageBox(self)msgBox.setWindowTitle("配置连招")  # 设置消息框标题msgBox.setIcon(QMessageBox.Information)msgBox.setText("当前连招:" + state.LIANZHAO + "\n请选择一个配置方式:")msgBox.addButton("录制", QMessageBox.AcceptRole)msgBox.addButton("回放", QMessageBox.ApplyRole)msgBox.addButton("文件中选择", QMessageBox.RejectRole)result = msgBox.exec_()if result == QMessageBox.AcceptRole:try:text, ok = QInputDialog.getText(self, '提示', '请输入脚本名:', text=state.LIANZHAO)if not ok:returnif text == "":returnelif text[-4:] != ".txt":state.LIANZHAO = text + ".txt"else:state.LIANZHAO = textprint("可以开始录制了,按F8开始/停止")self.sg.mysig_tishi.emit("可以开始录制了,按F8开始/停止")state.状态_是否禁止录制 = Falsestate.状态_是否开始录制 = Falsestate.录制_脚本文本 = ""tangbaowss.send_msg("是否禁止录制#@@#假")tangbaowss.send_msg("是否开始录制#@@#假")tangbaowss.send_msg(f"全局脚本名#@@#{state.LIANZHAO.replace('.txt', '')}")# hwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄hwnd = 25036058tangbaowss.send_msg(f"全局hwnd#@@#{hwnd}")self.timer_luzhi_lianzhao.start(200)except:passelif result == QMessageBox.RejectRole:if state.状态_是否回放中 == True:returnif not os.path.exists(state.PATH_JIAOBEN):os.makedirs(state.PATH_JIAOBEN)state.状态_是否回放中 = Truestate.状态_循环开关 = Truejiaoben = os.path.abspath(os.path.join(state.PATH_JIAOBEN, state.LIANZHAO))message = f"解析脚本#@@#{jiaoben}"tangbaowss.send_msg(message)hwnd = win32gui.FindWindow("UnityWndClass", state.GAME_TITLE)  # 替换成你实际的窗口句柄set_window_activate(hwnd)tangbaowss.send_msg("脚本执行#@@#1")self.timer_huifang.start(200)elif result == QMessageBox.Warning:self.hotkey_setlianzhao()def hotkey_setlianzhao(self):# 弹出一个有分组框的窗口temp_path, ok = QFileDialog.getOpenFileName(self, "连招脚本", state.PATH_JIAOBEN, "脚本文件 (*.txt)")if ok:_, state.LIANZHAO = os.path.split(temp_path)dir_ = os.path.join(state.PATH_JIAOBEN, state.LIANZHAO)try:shutil.copy(temp_path, dir_)except:passprint("选择连招脚本成功!")self.save_ini_seting()def hotkey_run_times(self):try:text, ok = QInputDialog.getText(self, '执行次数', f'当前任务包:{state.PATH_TASK}\n请输入执行次数:',text=str(self.run_times))if not ok:returnif text == "":returnif int(text) < 1:self.run_times = 1else:self.run_times = int(text)self.action_run_times.setText(f"设置:当前任务包 执行次数:{self.run_times}")print(f"设置:当前任务包 执行次数:{self.run_times}")# 创建 ConfigParser 对象config_main = configparser.ConfigParser()# 添加节和键-值对config_main['seting'] = {"run_times": str(self.run_times),}# 写入配置到 INI 文件with open(os.path.join(state.PATH_TASK, "细节参数.ini"), 'w') as configfile:config_main.write(configfile)except:passdef show_xunlu(self, image_path="./datas/111.png"):# 加载本地图片pixmap = QPixmap(image_path)# 设置图片到 lb_xunlu 控件self.fromshow.lb_xunlu.setPixmap(pixmap)# 设置宽度固定，高度自适应self.fromshow.window_width = int(self.fromshow.window_height * pixmap.width() / pixmap.height())self.fromshow.lb_xunlu.setFixedHeight(self.fromshow.window_height)self.fromshow.lb_xunlu.setFixedWidth(self.fromshow.window_width)self.fromshow.lb_xunlu.setScaledContents(True)def show_yolov(self, image_path="./datas/111.png"):# 加载本地图片pixmap1 = QPixmap(image_path)# 设置图片到 lb_yolov 控件self.fromshow.lb_yolov.setPixmap(pixmap1)# 根据窗口宽度调整 lb_yolov 的位置if self.fromshow.width() >= self.fromshow.lb_yolov.width() + self.fromshow.lb_xunlu.width():self.fromshow.lb_yolov.move(self.fromshow.lb_xunlu.width(), 0)else:self.fromshow.lb_yolov.move(0, self.fromshow.lb_xunlu.height())# 打开预测窗口def hotkey_isShow(self):# 尝试创建悬浮窗口实例if not hasattr(self, "fromshow"):self.fromshow = FormShow(self)  # 创建悬浮窗口实例self.addDockWidget(Qt.TopDockWidgetArea, self.fromshow)  # 添加悬浮窗口到主窗口# 更新布局def update_layout(self):try:# 获取主窗口的宽度width = self.centralWidget().width()# 计算每行可以容纳的组件数量num_per_row = (width) // (self.column_step * ratio)if num_per_row < 1:num_per_row = 1# 清空当前布局for i in reversed(range(self.g_box.count())):self.g_box.itemAt(i).widget().setParent(None)# 重新添加组件到网格布局for i, data in enumerate(self.datas):self.row = int(i // num_per_row)self.column = int(i % num_per_row)self.g_box.addWidget(data["f_item"], self.row, self.column)except:pass# 设置主窗口样式def set_ui(self):# 设置主题样式为 Flatwhitefrom qt_material import apply_stylesheetapply_stylesheet(app, theme='dark_pink.xml')# 设置窗口样式表self.setStyleSheet("""QScrollBar::handle:horizontal {background-color: #A50F2C;  /* 设置滑块颜色 */}QScrollBar::handle:horizontal:hover {background-color: #FF1744;  /* 设置滑块颜色 */}QPushButton:hover {background-color: #DFC472;  /* 设置颜色 */}QPlainTextEdit {padding: 0px;margin: 0px;}QPushButton {padding: 0px;margin: 1px;}""" + "font-family: {}; font-size: {}pt;".format(font.family(), font.pointSize()))# 主程序入口
if __name__ == '__main__':# 获取屏幕宽度和高度screen_width = ctypes.windll.user32.GetSystemMetrics(0)screen_height = ctypes.windll.user32.GetSystemMetrics(1)# 初始化QT应用app = QApplication(sys.argv)# 计算分辨率比例ratio = screen_width / 2560# 设置全局字体大小base_font_size = 13new_font_size = int(base_font_size * ratio)font = QFont("Arial", new_font_size)item_width = 320item_height = 240item_height_min = 60# 创建主窗口实例window_main = MainWindow()# 显示主窗口window_main.show()# 监听消息不关闭sys.exit(app.exec_())

9、测试

我们打开一个新文件夹，然后获取到句柄后进行修改，我上面这个全量代码

hotkey_addlianzhao函数中 强制写死了hwn窗口句柄id，hwnd = 25036058  注意修改

下面演示我们先点文件--添加录制，按一下F8，然后在所需窗口内输入自己想要的操作，然后在按一次F8即可保存文件操作记录文件

 

 

现在我们已经能拿到录制的脚本操作了，我们要给qt上进行添加

10、添加子任务

test.txt直接用我们上面拿到的录制 文件

vi jiaoben.ini

[seting]
type = 3
name = 滑翔
cb_auto_f = False
jiaoben = test.txt
chuansong = 
cbb_address = 手动录制
chuansongmoban = 
maodianmoban = 
cb_is_checked = True

update_tasks 函数会根据我们脚本中的type =3 来判断添加什么类型的任务

                    elif config.get('seting', 'type', fallback='1') == "3":# 脚本任务self.add_taskjiaoben(item_path, config)#这里原本是被注释的

11、添加任务脚本

    def add_taskjiaoben(self, dir_, config):'''添加脚本任务:return:'''# 根据导入的文件# 获取主窗口的宽度width = self.centralWidget().width()# 计算每行可以容纳的组件数量num_per_row = (width) // (self.column_step * ratio)  # 假设每个组件的宽度为200if num_per_row < 1:num_per_row = 1self.column += 1if self.column == num_per_row:self.column = 0self.row += 1# 加载ini配置文件f_item = FrameItemJiaoBen()f_item.setObjectName("frame_cont")f_item.raise_()f_item.setStyleSheet("""#frame_cont:hover {border: 1px solid red;}#frame_cont {background-color: rgba(0, 0, 0, 0);}""")d = {}d["type"] = "3"dir_ = dir_.replace("/", "\\")if dir_[-1] == "\\":dir_ = dir_[:-1]try:config.set('seting', 'name', dir_.split("\\")[-1].strip())except:# 添加一个名为 'seting' 的配置节config.add_section('seting')config.set('seting', 'name', dir_.split("\\")[-1].strip())d["name"] = config.get('seting', 'name', fallback=dir_.split("\\")[-1]).strip()d["cb_auto_f"] = config.get('seting', 'cb_auto_f', fallback='True')d["chuansong"] = config.get('seting', 'chuansong', fallback='')d["cbb_address"] = config.get('seting', 'cbb_address', fallback='手动录制')d["jiaoben"] = config.get('seting', 'jiaoben', fallback='')d["chuansongmoban"] = config.get('seting', 'chuansongmoban', fallback='')d["maodianmoban"] = config.get('seting', 'maodianmoban', fallback='')d["cb_is_checked"] = config.get('seting', 'cb_is_checked', fallback='True')f_item.bt_chuansong.setProperty("OK_chuansong", d["chuansong"] != "")f_item.bt_jiaoben.setProperty("OK_jiaoben", d["jiaoben"] != "")f_item.bt_moban.setProperty("OK_chuansongmoban", d["chuansongmoban"] != "")f_item.bt_moban_maodian.setProperty("OK_maodianmoban", d["maodianmoban"] != "")f_item.bt_chuansong.setObjectName("bt_chuansong")f_item.bt_moban.setObjectName("bt_moban")f_item.bt_moban_maodian.setObjectName("bt_moban_maodian")f_item.led_name.setText(d["name"])f_item.bt_jiaoben.setStyleSheet("""#bt_jiaoben[OK_jiaoben="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")f_item.bt_chuansong.setStyleSheet("""#bt_chuansong[OK_chuansong="true"] {color: rgb(237,182,43);  border-color: rgb(237,182,43); }""")f_item.bt_moban.setStyleSheet("""#bt_moban[OK_chuansongmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")f_item.bt_moban_maodian.setStyleSheet("""#bt_moban_maodian[OK_maodianmoban="true"] {color: rgb(237,182,43); border-color: rgb(237,182,43); }""")if d["cb_is_checked"] == "True":f_item.cb_is_checked.setChecked(True)else:f_item.cb_is_checked.setChecked(False)if d["cb_auto_f"] == "True":f_item.cb_auto_f.setChecked(True)else:f_item.cb_auto_f.setChecked(False)idex = len(self.datas)f_item.bt_jiaoben.clicked.connect(functools.partial(self.clickd_bt_jiaoben, idex))f_item.bt_chuansong.clicked.connect(functools.partial(self.clickd_bt_chuansong, idex))f_item.bt_moban.clicked.connect(functools.partial(self.clickd_bt_moban, idex))f_item.bt_moban_maodian.clicked.connect(functools.partial(self.clickd_bt_moban_maodian, idex))f_item.bt_start.clicked.connect(functools.partial(self.clickd_bt_start, idex))f_item.bt_del.clicked.connect(functools.partial(self.clickd_bt_del, idex))d["f_item"] = f_itemf_item.bt_start.setVisible(False)f_item.bt_jiaoben.setVisible(False)f_item.bt_chuansong.setVisible(False)f_item.bt_moban_maodian.setVisible(False)f_item.bt_moban.setVisible(False)f_item.bt_start.setVisible(False)f_item.bt_del.setVisible(False)f_item.cb_auto_f.setVisible(False)f_item.bt_moban.setToolTip(self.tanChu_img(dir_ + "/" + d["chuansongmoban"]))f_item.bt_moban_maodian.setToolTip(self.tanChu_img(dir_ + "/" + d["maodianmoban"]))self.datas.append(d)self.g_box.addWidget(f_item, self.row, self.column)

12、添加ui配置

class FrameItemJiaoBen(QFrame, Ui_formitemjiaoben):def __init__(self, parent=None):super(QFrame, self).__init__(parent)self.setupUi(self)self.set_ui()self.is_zd = Falsew = int(item_width * ratio)h = int(item_height_min * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)# self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint | Qt.WindowStaysOnTopHint)def set_ui(self):passdef mousePressEvent(self, event):if not self.is_zd:self.is_zd = not self.is_zd# 在这里添加鼠标进入时的逻辑w = int(item_width * ratio)h = int(item_height * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)self.bt_start.setVisible(True)self.bt_jiaoben.setVisible(True)self.bt_chuansong.setVisible(True)self.bt_moban_maodian.setVisible(True)self.bt_moban.setVisible(True)self.bt_start.setVisible(True)self.bt_del.setVisible(True)self.cb_auto_f.setVisible(True)else:self.is_zd = not self.is_zdw = int(item_width * ratio)h = int(item_height_min * ratio)self.setMinimumSize(w + int(1 * ratio), h)self.setMaximumSize(w, h)self.bt_start.setVisible(False)self.bt_jiaoben.setVisible(False)self.bt_chuansong.setVisible(False)self.bt_moban_maodian.setVisible(False)self.bt_moban.setVisible(False)self.bt_start.setVisible(False)self.bt_del.setVisible(False)self.cb_auto_f.setVisible(False)

13、添加ui xml

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0"><class>formitemjiaoben</class><widget class="QWidget" name="formitemjiaoben"><property name="geometry"><rect><x>0</x><y>0</y><width>229</width><height>155</height></rect></property><property name="windowTitle"><string>Form</string></property><layout class="QGridLayout" name="gridLayout"><item row="0" column="0" colspan="4"><layout class="QHBoxLayout" name="horizontalLayout"><item><widget class="QLineEdit" name="led_name"><property name="minimumSize"><size><width>0</width><height>0</height></size></property><property name="maximumSize"><size><width>999</width><height>9999</height></size></property><property name="styleSheet"><string notr="true">color: rgb(255, 255, 255);</string></property><property name="text"><string>蒙德锄地</string></property><property name="alignment"><set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set></property></widget></item><item><widget class="QCheckBox" name="cb_is_checked"><property name="minimumSize"><size><width>0</width><height>0</height></size></property><property name="maximumSize"><size><width>999999</width><height>9999999</height></size></property><property name="layoutDirection"><enum>Qt::RightToLeft</enum></property><property name="styleSheet"><string notr="true"/></property><property name="text"><string/></property><property name="checked"><bool>true</bool></property></widget></item></layout></item><item row="1" column="0" colspan="2"><widget class="QCheckBox" name="cb_auto_f"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="font"><font><family>ADMUI3Lg</family><pointsize>14</pointsize></font></property><property name="focusPolicy"><enum>Qt::TabFocus</enum></property><property name="text"><string>自动按F</string></property><property name="checked"><bool>true</bool></property></widget></item><item row="1" column="2"><widget class="QPushButton" name="bt_jiaoben"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>脚本</string></property></widget></item><item row="1" column="3"><widget class="QPushButton" name="bt_start"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>启动</string></property></widget></item><item row="2" column="0"><widget class="QPushButton" name="bt_chuansong"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>传送
脚本</string></property></widget></item><item row="2" column="1"><widget class="QPushButton" name="bt_moban"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>传送
模板</string></property></widget></item><item row="2" column="2"><widget class="QPushButton" name="bt_moban_maodian"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>锚点
模板</string></property></widget></item><item row="2" column="3"><widget class="QPushButton" name="bt_del"><property name="minimumSize"><size><width>50</width><height>50</height></size></property><property name="maximumSize"><size><width>999999</width><height>999999</height></size></property><property name="text"><string>删除
任务</string></property></widget></item></layout></widget><resources/><connections/>
</ui>

记得转py文件

 13、

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

最新新闻

热搜词

为什么现在还有很多企业在做电销 Ubuntu打开nvvp报错 javafx-请求篇 01Thingsboard中actor和RuleEngine的启动流程 基于物联网设计的地下煤矿安全监测与预警 智能网联汽车网络安全开发解决方案

声明：本站所有新闻及新闻图片来源于其他网站，如有侵权，请及时联系我们！

客户服务 | 关于我们 | 版权声明

版权所有：

Copyright 2024 尧图网 All Rights Reserved.QQ:809451989