def on_release(key):
print('{0} release'.format(
key))
if key == Key.esc:
# Stop listener
mListener.stop()
return False
def listen():
"Listen for inputs and forward them to the TV (CTRL-C to exit)"
try:
from pynput.mouse import Listener as MListener
c = Client()
c.ic.connect_input()
c.last_x = c.last_y = None
def on_move(x, y):
if c.last_x == None:
c.last_x, c.last_y = x, y
else:
c.ic.move(x - c.last_x, y - c.last_y)
c.last_x, c.last_y = x, y
# print('Pointer moved to {0}'.format((x, y)))
def on_click(x, y, button, pressed):
c.ic.click()
def on_scroll(x, y, dx, dy):
print(f"Scrolled {'down' if dy < 0 else 'up'} at {(x,y)}")
m = MListener(on_move=on_move, on_click=on_click, on_scroll=on_scroll)
m.start()
while True:
inp = click.getchar()
mapped = KEYMAP.get(inp)
if not mapped:
click.echo(f"Don't know what to do with '{inp}'", err=True)
else:
getattr(getattr(c, mapped[0]), mapped[1])()
except KeyboardInterrupt:
m.stop()
class globalMouseHook(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.isLeftDown = False
self.isRightDown = False
def on_move(self, x, y):
# print('Pointer at {0}'.format((x, y)))
return
def on_click(self, x, y, button, pressed):
# print('{0} at {1} with {2}'.format('Pressed' if pressed else 'Released', (x, y), button))
if button == Button.left:
self.isLeftDown = not self.isLeftDown
elif button == Button.right:
self.isRightDown = not self.isRightDown
def is_leftDown(self):
return self.isLeftDown
def is_rightDown(self):
return self.isRightDown
def run(self):
# Collect events until released
self.listener = Listener(on_move=self.on_move, on_click=self.on_click)
self.listener.start()
def stop(self):
self.listener.stop()
def roll_manager(self, area):
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed):
print(x, y, button)
if area[0] < x < area[0] + area[2] and area[1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
def on_scroll(x, y, button, pressed):
self.mode = 0
lis.stop()
self.tips = TipsShower("单击自动滚动;\n或手动下滚;")
if x < QApplication.desktop().width() - x - w:
self.tips.move(x + w, y)
else:
self.tips.move(x - self.tips.width(), y)
self.showrect.setGeometry(x, y, w, h)
self.showrect.show()
QApplication.processEvents()
lis = MouseListenner(on_click=on_click, on_scroll=on_scroll)
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode:
print("auto_roll")
self.auto_roll(area)
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
class MouseListener:
def __init__(self, output_file: str):
self.file = None
try:
self.file = open(output_file, mode='w', encoding='utf-8')
except ValueError:
print('error : text.txt doesn\' exists .', file=sys.stderr)
self.listener = Listener(on_move=self.on_move,
on_click=self.on_click)
def on_move(self, x, y):
self.file.write(f'mouse move: ({x},{y})\n')
def on_click(self, x, y, button, pressed):
if pressed:
self.file.write(f'mouse pressed {button}: ({x},{y})\n')
else:
self.file.write(f'mouse released {button}: ({x},{y})\n')
def start(self):
self.listener.start()
self.listener.join()
def stop(self):
self.listener.stop()
self.file.close()
class SlotRandomizer():
def __init__(self):
self.keyboard = KeyboardController()
self.listener = MouseListener(on_click=self.onClick)
self.slotWeights = [0] * 9
def onClick(self, x, y, button, pressed):
if button != Button.right or not pressed:
return True
time.sleep(0.05)
slot = random.choices(
population=range(1, 10), weights=self.slotWeights
)[0]
key = KeyCode.from_vk(0x30 + slot)
self.keyboard.press(key)
time.sleep(0.05)
self.keyboard.release(key)
def startListener(self):
self.listener = MouseListener(on_click=self.onClick)
self.listener.start()
def stopListener(self):
self.listener.stop()
self.listener = None
def on_click(x, y, button, pressed):
global total_mouse_clicks
get_active_window()
total_mouse_clicks += 1
if running == False:
MouseListener.stop()
return False
def scroll_to_roll(self, area): # 手动滚动模式
x, y, w, h = area
self.rollermask.tips.setText("向下滚动,单击结束")
QApplication.processEvents()
screen = QApplication.primaryScreen()
winid = QApplication.desktop().winId()
self.id = self.rid = 0
self.a_step = 0
def onclick(x, y, button, pressed):
if pressed:
pix = screen.grabWindow(winid, x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
else:
print("click to stop", len(self.img_list))
self.in_rolling = False
listener.stop()
def on_scroll(px, py, x_axis, y_axis):
# print(px, py, x_axis, y_axis)
# if not self.inthearea((px,py),area):
# return
self.a_step += 1
if self.a_step < 2:
return
else:
self.a_step = 0
if y_axis < 0:
if self.rid >= self.id: # 当滚动id与真实id一样时说明
pix = screen.grabWindow(winid, x, y, w, h) # 滚动段距离进行截屏
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
# cv2.imwrite("j_temp/{}.png".format(self.id), img)
self.id += 1 # 记录当前滚动的id
self.rid = self.id
else: # 不一样时说明用户往回滚了,跳过
print("跳过")
self.rid += 1
else: # 方向往回滚时id-1,以记录往回的步数
self.rid -= 1
print("方向错误")
listener = MouseListenner(on_click=onclick,
on_scroll=on_scroll) # 鼠标监听器,传入函数句柄
self.match_thread = Commen_Thread(
self.match_and_merge) # 也是把拼接函数放入后台线程中
self.in_rolling = True
i = 0
listener.start() # 鼠标监听器启动
self.match_thread.start() # 拼接线程启动
while self.in_rolling: # 等待结束滚动
time.sleep(0.2)
listener.stop()
# self.showrect.hide()
self.match_thread.wait() # 等待拼接线程结束
def on_press(key):
# print("Key pressed: {0}".format(key))
if key == Key.esc:
print("Key pressed: {0}".format(key))
# return False
KeyboardListener.stop()
MouseListener.stop()
def on_click(x, y, button, pressed):
print('{0} at {1}'.format('pressed' if pressed else 'released',(x, y)))
click_location = (x,y) #actually prints the location of the mouse when clicked
print('Click location =',click_location)
print('exeted listener')
Listener.stop() #Gotta remember the cap
def on_release(key):
print('{0} release'.format(key))
if key == Key.esc:
# Stop listener
mListener.stop()
return False
# set trigger for a detector?
if key == Key.shift:
print(mouse.position)
def scroll_to_roll(self, area):
x, y, w, h = area
self.rollermask.tips.setText("向下滚动,单击结束")
QApplication.processEvents()
screen = QApplication.primaryScreen()
winid = QApplication.desktop().winId()
self.id = self.rid = 0
self.a_step = 0
def onclick(x, y, button, pressed):
if pressed:
pix = screen.grabWindow(winid, x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
else:
print("click to stop", len(self.img_list))
self.in_rolling = False
listener.stop()
def on_scroll(px, py, x_axis, y_axis):
print(px, py, x_axis, y_axis)
# if not self.inthearea((px,py),area):
# return
self.a_step += 1
if self.a_step < 2:
return
else:
self.a_step = 0
if y_axis < 0:
if self.rid >= self.id:
pix = screen.grabWindow(winid, x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
# cv2.imwrite("j_temp/{}.png".format(self.id), img)
self.id += 1
self.rid = self.id
else:
print("跳过")
self.rid += 1
else:
self.rid -= 1
print("方向错误")
listener = MouseListenner(on_click=onclick, on_scroll=on_scroll)
self.match_thread = Commen_Thread(self.match_and_merge)
self.in_rolling = True
i = 0
listener.start()
self.match_thread.start()
while self.in_rolling:
time.sleep(0.2)
listener.stop()
# self.showrect.hide()
self.match_thread.wait()
def get_size():
global click1, click2
listener = Listener(on_click=on_click)
listener.start()
while not click1:
pass
while not click2:
pass
listener.stop()
return (click2[1] - click1[1], click2[0] - click1[0]), click1
def listen(self):
" Listen and send keys and mouse event until CTRL LEFT is pressed "
print('Press on CTRL LEFT to stop listening')
s = S()
s.ic.connect_input()
keymap = {
'esc': s.ic.exit,
'enter': s.ic.click,
'backspace': s.ic.back,
'=': s.ic.volume_up,
'-': s.ic.volume_down,
'i': s.ic.info,
'h': s.ic.home,
'm': self.mute
}
def on_press(key):
print(key)
if key == pynput.keyboard.Key.ctrl_l:
return False
if hasattr(key, 'name'):
if key.name in keymap:
keymap.get(key.name)()
elif key.name in InputControl.INPUT_COMMANDS:
getattr(s.ic, key.name)()
elif hasattr(key, 'char'):
if key.char in keymap:
keymap.get(key.char)()
elif key.char in InputControl.INPUT_COMMANDS:
getattr(s.ic, key.char)()
def on_move(x, y):
if self.last_x == None:
self.last_x, self.last_y = x, y
else:
s.ic.move(x - self.last_x, y - self.last_y)
self.last_x, self.last_y = x, y
# print('Pointer moved to {0}'.format((x, y)))
def on_click(x, y, button, pressed):
s.ic.click()
def on_scroll(x, y, dx, dy):
print('Scrolled {0} at {1}'.format('down' if dy < 0 else 'up',
(x, y)))
# Collect events until released
m = MListener(on_move=on_move, on_click=on_click, on_scroll=on_scroll)
m.start()
with KListener(on_press=on_press) as listener:
listener.join()
m.stop()
s.ic.disconnect_input()
class Recorder:
_filename: str
_listener: Listener
_output: TextIO
_start_time: datetime
_stop_time: datetime
def __init__(self, filename: str):
self._filename = filename
self._listener = Listener(on_click=self._on_click)
signal.signal(signal.SIGINT, self._signal_handler)
self._output = open(self._filename, 'w')
self._write("MACRO macro_name {")
def record(self):
with self._listener:
self._listener.join()
def _signal_handler(self, sig, frame):
print('Exiting...')
self._listener.stop()
self._write("}")
self._output.close()
def _write(self, data: str):
self._output.write(f"{data}\n")
self._output.flush()
def _get_second_delta(self) -> Optional[int]:
try:
return int((self._stop_time - self._start_time).total_seconds())
except (AttributeError, ValueError):
return None
def _on_click(self, x, y, button, pressed):
self._stop_time = datetime.now()
x = int(x)
y = int(y)
if self._get_second_delta() is not None \
and self._get_second_delta() > 0:
print(f"Wait {self._get_second_delta()} seconds")
self._write(f" WAIT {self._get_second_delta()}s")
if pressed:
print(f"Mouse clicked at ({x}, {y})")
self._write(f" CLICK {x},{y}")
self._start_time = datetime.now()
def start_record(self):
self.log = open(self.replay_file, "w")
self.init_time = time.time() * 1000 # To make microseconds
keyboard_listener = KeyboardListener(on_press=self.__on_press,
on_release=self.__on_release)
mouse_listener = MouseListener(on_click=self.__on_click,
on_scroll=self.__on_scroll)
keyboard_listener.start()
mouse_listener.start()
keyboard_listener.join()
mouse_listener.stop()
keyboard_listener.stop()
self.log.flush()
self.log.close()
def auto_roll(self, area): # 自动滚动模式
x, y, w, h = area
self.rollermask.tips.setText("单击停止")
QApplication.processEvents()
speed = round(1 / self.roll_speed, 2)
screen = QApplication.primaryScreen()
winid = QApplication.desktop().winId()
def onclick(x, y, button, pressed): # 点击退出的函数句柄
if pressed:
print("click to stop")
self.in_rolling = False
listener.stop()
controler = MouseController() # 鼠标控制器
listener = MouseListenner(on_click=onclick) # 鼠标监听器
self.match_thread = Commen_Thread(
self.match_and_merge) # 把match_and_merge放入一个线程中
self.in_rolling = True
i = 0
controler.position = (area[0] + int(area[2] / 2),
area[1] + int(area[3] / 2)) # 控制鼠标点击到滚动区域中心
oldimg = Image.new("RGB", (128, 128), "#FF0f00")
listener.start()
while self.in_rolling:
st = time.time()
pix = screen.grabWindow(winid, x, y, w, h) # 截屏
newimg = Image.fromqpixmap(pix) # 转化为pil的格式
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img) # 图片数据存入self.img_list中被后台的拼接线程使用
# cv2.imshow("FSd", img)
# cv2.waitKey(0)
if i >= 1:
if i == 1:
self.match_thread.start() # 当截第二张图片时拼接线程才启动
if self.is_same(oldimg, newimg): # 每帧检查是否停止
self.in_rolling = False
i += 1
break
oldimg = newimg
controler.scroll(dx=0, dy=-3) # 控制鼠标滚动
time.sleep(speed) # 通过sleep控制自动滚动速度
# cv2.imwrite('j_temp/{0}.png'.format(i), img)
i += 1
print("结束滚动,共截屏{}张".format(i))
listener.stop()
# self.showrect.hide()
self.match_thread.wait()
class Listener:
def __init__(self):
self.keyboard_listener = KeyboardListener(on_press=on_press,
on_release=on_release)
self.mouse_listener = MouseListener(on_click=on_click,
on_scroll=on_scroll,
on_move=on_move)
def start(self):
self.keyboard_listener.start()
self.mouse_listener.start()
def stop(self):
self.keyboard_listener.stop()
self.mouse_listener.stop()
class MouseListener:
def __init__(self, on_click_function):
self.on_click = on_click_function
def start_listening(self):
# non-blocking
# a Listener can only be started once, so I must create a new one every time
if hasattr(self, "_listener") and self._listener.running is True:
self._listener.stop()
self._listener = Listener(on_click=self.on_click)
self._listener.start()
def stop_listening(self):
if hasattr(self, "_listener") and self._listener.running is True:
self._listener.stop()
def gaming(ip):
port = 5000
game_machine = socket.socket()
game_machine.connect((ip, port))
data = game_machine.recv(4096)
print("Message received: ", data.decode())
mouse = MouseController()
mouse_listener = MouseListener(on_click=on_click)
mouse_listener.start()
keyboard = KeyController()
keyboard_listener = KeyListener(on_press=on_press, on_release=on_release)
keyboard_listener.start()
width, height = send_resolution(game_machine)
# Streaming video
while True:
# Retrieves frame
frame = stream(game_machine)
# Displays frame
cv2.namedWindow("Streaming", cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty("Streaming", cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
cv2.imshow("Streaming", frame)
if cv2.waitKey(1) == 27:
break
game_machine.send("Received".encode())
print("Received")
# Send mouse position
send_mouse_pos(game_machine, mouse, width, height)
# Send mouse clicks
send_mouse_clicks(game_machine, CLICKS)
CLICKS.clear()
# Send keyboard input
send_keyboard_input(game_machine, KEYPRESS)
KEYPRESS.clear()
CURRENT_KEY.clear()
keyboard_listener.stop()
mouse_listener.stop()
cv2.destroyAllWindows()
game_machine.close()
def auto_roll(self, area):
x, y, w, h = area
self.tips.setText("单击停止")
QApplication.processEvents()
speed = round(1 / self.roll_speed, 2)
screen = QApplication.primaryScreen()
winid = QApplication.desktop().winId()
def onclick(x, y, button, pressed):
if pressed:
print("click to stop")
self.in_rolling = False
listener.stop()
controler = MouseController()
listener = MouseListenner(on_click=onclick)
self.match_thread = Commen_Thread(self.match_and_merge)
self.in_rolling = True
i = 0
controler.position = (area[0] + int(area[2] / 2), area[1] + int(area[3] / 2))
oldimg = Image.new("RGB", (128, 128), "#FF0f00")
listener.start()
while self.in_rolling:
st = time.time()
pix = screen.grabWindow(winid, x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(np.asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
# cv2.imshow("FSd", img)
# cv2.waitKey(0)
if i >= 1:
if i == 1:
self.match_thread.start()
if self.is_same(oldimg, newimg): # 每帧检查是否停止
self.in_rolling = False
i += 1
break
oldimg = newimg
controler.scroll(dx=0, dy=-3)
time.sleep(speed)
# cv2.imwrite('j_temp/{0}.png'.format(i), img)
i += 1
print("结束滚动,共截屏{}张".format(i))
listener.stop()
self.showrect.hide()
self.match_thread.wait()
self.showm_signal.emit("长截图完成")
class MouseTracker:
def __init__(self):
self.track = True
self.started_timestamp = time.time()
self.listener = None
self.reactivate()
def on_move(self, x, y):
timestamp = time.time()
s = "Movement {0:.4f} {1} {2} None Move {3}".format(
timestamp, x, y, get_window_name())
log(s)
def on_click(self, x, y, button, pressed):
timestamp = time.time()
s = "Click {0:.4f} {1} {2}".format(timestamp, x, y)
if pressed: # press or release check
if str(button) == "Button.right":
s += " Right Pressed "
elif str(button) == "Button.left":
s += " Left Pressed "
else:
if str(button) == "Button.right":
s += " Right Released "
elif str(button) == "Button.left":
s += " Left Released "
s += get_window_name()
log(s)
def start_listening(self):
try:
self.stop_listening()
except:
pass
self.listener = Listener(on_move=self.on_move, on_click=self.on_click)
self.listener.start()
def stop_listening(self):
try:
self.listener.stop()
except:
pass
def reactivate(self):
rt = RepeatedTimer(1800, self.start_listening) # 3600 saniye = 1 saat
def roll_manager(self, area): # 滚动截屏控制器,控制滚动截屏的模式(自动还是手动滚)
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed): # 用户点击了屏幕说明用户想自动滚
print(x, y, button)
if button == mouse.Button.left:
if area[0] < x < area[0] + area[2] and area[
1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
elif button == mouse.Button.right:
self.mode = 2
lis.stop()
def on_scroll(x, y, button, pressed): # 用户滚动了鼠标说明用户想要手动滚
self.mode = 0
lis.stop()
self.rollermask = roller_mask(area) # 滚动截屏遮罩层初始化
# self.showrect.setGeometry(x, y, w, h)
# self.showrect.show()
pix = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), x, y, w, h) # 先截一张图片
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
QApplication.processEvents()
lis = MouseListenner(on_click=on_click,
on_scroll=on_scroll) # 鼠标监听器初始化并启动
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode == 1: # 判断用户选择的模式
print("auto_roll")
self.auto_roll(area)
elif self.mode == 2:
print("exit roller")
return 1
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
self.showm_signal.emit("长截图完成")
self.rollermask.hide()
return 0
def func2():
listener = Listener(on_move=on_move,
on_click=on_click,
on_scroll=on_scroll)
start = '00:00:00'
printer = False
while True:
if keyboard.is_pressed('1'):
if not printer:
print('mouse recorder started')
printer = True
if not listener.is_alive():
listener.start()
if keyboard.is_pressed('0') and listener.is_alive():
listener.stop()
with open('mouse_tracker.json', 'w+') as f:
f.write(json.dumps(mouse_tracker))
break
def roll_manager(self, area):
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed):
print(x, y, button)
if area[0] < x < area[0] + area[2] and area[
1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
def on_scroll(x, y, button, pressed):
self.mode = 0
lis.stop()
self.rollermask = roller_mask(area)
# self.showrect.setGeometry(x, y, w, h)
# self.showrect.show()
pix = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
QApplication.processEvents()
lis = MouseListenner(on_click=on_click, on_scroll=on_scroll)
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode:
print("auto_roll")
self.auto_roll(area)
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
self.showm_signal.emit("长截图完成")
self.rollermask.hide()
class NativeMouseListener():
def __init__(self):
self.listener = None
def start(self):
self.listener = Listener(
on_click=self.on_click, on_scroll=self.on_scroll)
self.listener.start()
def stop(self):
if self.listener:
self.listener.stop()
self.listener = None
@staticmethod
def on_click(x, y, button, pressed):
if button not in MESSAGE_BUTTON:
return
sys.stdout.buffer.write(MESSAGE_CLICK_LENGTH)
sys.stdout.buffer.write(MESSAGE_STRING_DELIMITER)
sys.stdout.buffer.write(MESSAGE_CLICK_PREFIX)
sys.stdout.buffer.write(
MESSAGE_BUTTON_DOWN if pressed else MESSAGE_BUTTON_UP)
sys.stdout.buffer.write(MESSAGE_BUTTON[button])
sys.stdout.buffer.write(MESSAGE_STRING_DELIMITER)
sys.stdout.buffer.flush()
@staticmethod
def on_scroll(x, y, dx, dy):
sys.stdout.buffer.write(MESSAGE_SCROLL_LENGTH)
sys.stdout.buffer.write(MESSAGE_STRING_DELIMITER)
sys.stdout.buffer.write(MESSAGE_SCROLL_PREFIX)
sys.stdout.buffer.write(
MESSAGE_SCROLL_DOWN if dy > 0 else MESSAGE_SCROLL_UP)
sys.stdout.buffer.write(MESSAGE_STRING_DELIMITER)
sys.stdout.buffer.flush()
class WxExportPanel(wx.Panel):
mouselogger: MouseListener = None
keylogger: KeyListener = None
def __init__(self, parent):
super().__init__(parent)
self.mouselogger = MouseListener(on_click=self.on_click,
on_scroll=self.on_scroll)
self.keylogger = KeyListener(on_press=self.on_press,
on_release=self.on_release)
main_sizer_vert = wx.BoxSizer(wx.VERTICAL)
main_sizer_vert.AddStretchSpacer()
# Create the "Start (to Tray)"-Button
self.wx_button_export = wx.Button(self, label="Start")
self.wx_button_export.Bind(wx.EVT_BUTTON, self.toggle_logging)
main_sizer_vert.Add(self.wx_button_export, 0, wx.TOP | wx.CENTER, 20)
#set the sizer of the panel
main_sizer_vert.AddStretchSpacer()
self.SetSizer(main_sizer_vert)
def on_log_path_set(self, event):
print('[ClickTrackLogger] on_log_path_set')
# Get the source path
self.log_path = self.wx_file_picker_log.GetPath()
def toggle_logging(self, event):
if not self.mouselogger.running or not self.keylogger.running:
self.mouselogger.start()
print('mouselogger started')
self.keylogger.start()
print('keylogger started')
self.wx_button_export.SetLabel('Stop')
else:
if self.mouselogger.running:
self.mouselogger.stop()
print('Mouselogger stoped')
if self.keylogger.running:
self.keylogger.stop()
print('Keylogger stoped')
self.wx_button_export.SetLabel('Start')
def on_click(self, x, y, button, pressed):
if pressed:
logging.info(f'mouse_click,{button},pos_x{x}_y{y}')
def on_scroll(self, x, y, dx, dy):
name = 'mouse_scroll'
if dy <= -1:
name += '_down'
if dy >= 1:
name += '_up'
if dx <= -1:
name += '_left'
if dx >= 1:
name += '_right'
logging.info(f'{name},MouseScroll,pos_x{x}_y{y}')
def on_press(self, key):
logging.info(f'keyboard_press,{str(key)},no_pos')
def on_release(self, key):
logging.info(f'keyboard_release,{str(key)},no_pos')
class MyMouseListener:
def __init__(self):
self.clicked = False
self.last_x_send = None
self.actual_x = None
self.last_y_send = None
self.actual_y = None
self.last_z_send = 0
self.actual_z = 0
self.mouse = Controller()
self.listener = Listener(on_move=self.on_move,
on_click=self.on_click,
on_scroll=self.on_scroll).start()
def __del__(self):
self.listener.stop()
def on_move(self, x, y):
if self.last_x_send is None:
self.last_x_send = x
self.last_y_send = y
self.actual_x = x
self.actual_y = y
def on_click(self, _x, _y, button, pressed):
if not pressed:
# self.mouse.release(button)
if button == Button.right:
self.clicked = True
elif button == Button.left:
self.actual_x = 960
self.actual_y = 1500
self.mouse.position = (self.actual_x, self.actual_y)
self.actual_z = 0
self.reset()
def on_scroll(self, _x, _y, _dx, dy):
self.actual_z += dy
def reset(self):
self.last_x_send = self.actual_x
self.last_y_send = self.actual_y
self.last_z_send = self.actual_z
def get_x_diff(self):
if self.last_x_send is None:
return 0
return self.actual_x - self.last_x_send
def get_y_diff(self):
if self.last_y_send is None:
return 0
return self.actual_y - self.last_y_send
def get_z_diff(self):
return self.actual_z - self.last_z_send
def __str__(self):
return ''
active_time = graph.active_time / running_time
active_time = round(100 * active_time, 2)
var_active.set("Active Time : {}%".format(active_time))
keys_clicks = graph.keypresses / max((graph.clicks + graph.keypresses), 1)
keys_clicks = round(100 * keys_clicks, 2)
var_cur.set("Current : {} APM".format(cur_apm))
var_cur_hover.set("{} APM".format(cur_apm))
var_max.set("Max : {} APM".format(max_apm))
var_avg.set("Avg : {} APM".format(avg_apm))
var_kc.set("Keypresses : {}%".format(keys_clicks))
Fenetre.update_idletasks()
if graph.active != "inactive":
stats.after(100, update_stats)
# Real-time moving average apm graphing
graph = Graph(Fenetre,
bg="black",
width=width,
height=3 * height // 4,
max_x=10,
max_y=10)
graph.place(x=0, y=height // 4)
graph.display(intro=True)
Fenetre.mainloop()
klistener.stop()
mlistener.stop()
class DelayParser(Thread):
"""Parser that checks Regeneration Delays and controls an overlay"""
DELAYS = {
"Power_Shield_Regen_Delay": "Shield",
"Power_Weapon_Regen_Delay": "Weapon",
"Power_Engine_Regen_Delay": "Engine"
}
POOLS = ["Weapon", "Shield", "Engine"]
STATS = {
"Delay": "Power_{}_Regen_Delay",
"Regen": "Power_{}_Regen_Rate",
"Recent": "Power_{}_Regen_Rate_(when_Recently_Consumed)"
}
def __init__(self):
"""Initialize as Thread and create attributes"""
Thread.__init__(self)
self._stats = {p: {k: 0.0 for k in self.STATS} for p in self.POOLS}
self._lock = Lock()
self._exit_queue = Queue()
self.primary = "PrimaryWeapon"
self.__delays = dict()
self._internal_q = Queue()
self._match = False
self._ms_listener = MSListener(on_click=self._on_click)
self._kb_listener = KBListener(on_press=self._on_press)
self._mouse = False
self._string = str()
print("[DelayParser] Initialized")
def set_ship_stats(self, ship: ShipStats):
"""Update the ship statistics used for delay tracking"""
self._lock.acquire()
self._stats = {
p: {k: ship["Ship"][v.format(p)] for k, v in self.STATS.items()}
for p in self.POOLS
}
self.primary = "PrimaryWeapon"
self._lock.release()
print("[DelayParser] Updated ship to: {}".format(ship.ship.name))
def primary_weapon_swap(self):
"""Swap the primary weapon key"""
self.primary = "PrimaryWeapon2" if self.primary == "PrimaryWeapon" else "PrimaryWeapon"
print("[DelayParser] Swapped Primary Weapons")
def match_end(self):
"""Match ended callback"""
self._internal_q.put("end")
def match_start(self):
"""Match start callback"""
self._internal_q.put("start")
def update(self):
"""Update the state of the DelayParser"""
self._lock.acquire()
stats, key = self._stats.copy(), self.primary
self._lock.release()
while not self._internal_q.empty():
v = self._internal_q.get()
if v == "start":
self._match = True
elif v == "end":
self._match = False
elif v == "mouse":
self._mouse = not self._mouse
else:
pool, time = v
self.__delays[pool] = time
if self._match is False:
return
if self._mouse is True:
self.__delays["Weapon"] = datetime.now()
string, time = "\n", datetime.now()
for pool, start in self.__delays.items():
elapsed = (time - start).total_seconds()
remaining = max(stats[pool]["Delay"] - elapsed, 0.0)
rate = stats[pool]["Regen"] if remaining == 0.0 else stats[pool]["Recent"]
string += "{}: {:.1f}s, {:.1f}pps\n".format(pool[0], remaining, rate)
self._lock.acquire()
self._string = string
self._lock.release()
sleep(0.1)
def process_event(self, event: dict, active_ids: list):
"""Process an event to check for shield power pool usage"""
ctg = Parser.get_event_category(event, active_ids)
if event["self"] is True and ctg == "engine":
self._internal_q.put(("Engine", event["time"]))
return
if event["self"] is True or Parser.compare_ids(event["target"], active_ids) is False:
return
if "Damage" not in event["effect"]:
return
# event: Damage dealt to self
self._internal_q.put(("Shield", event["time"]))
def cleanup(self):
"""Clean up everything in use"""
self._ms_listener.stop()
self._kb_listener.stop()
def run(self):
"""Run the Thread"""
self._ms_listener.start()
self._kb_listener.start()
print("[DelayParser] Keyboard and Mouse Listeners started")
while True:
if not self._exit_queue.empty():
break
self.update()
self.cleanup()
def stop(self):
"""Stop activities and join Thread"""
if not self.is_alive():
return
self._exit_queue.put(True)
self.join(timeout=1)
def _on_click(self, x: int, y: int, button: Button, state: bool):
"""Process a click to check for weapon power usage"""
if button == Button.left:
self._internal_q.put("mouse")
def _on_press(self, key: (Key, KeyCode)):
"""Process a key press to check for engine power usage"""
if key == Key.space:
self._internal_q.put(("Engine", datetime.now()))
@property
def string(self):
"""String to show in the Overlay"""
self._lock.acquire()
string = self._string
self._lock.release()
return string
class DataCollector(MouseListener, KeyboardListener):
def __init__(self, game_object):
self.game_object = game_object
self.events_list_array = []
self.start_time = time.time()
self.interval = 0.1
self.mouse_count = 0
self.mouse = Controller()
self.keyboard_listener = KeyboardListener(on_press=self.on_press,
on_release=self.on_release)
self.mouse_listener = MouseListener(on_move=self.on_move,
on_click=self.on_click,
on_scroll=self.on_scroll)
self.keyboard_listener.start()
self.mouse_listener.start()
self.listener_on(True)
def listener_on(self, statment):
if statment == True:
self.keyboard_listener.join()
self.mouse_listener.join()
elif statment == False:
self.keyboard_listener.stop()
self.mouse_listener.stop()
def _current_time(self):
clock = time.time() - self.start_time
clock = round(clock, 3)
return clock
def _current_day(self):
dt_date = datetime.datetime.now()
return dt_date.strftime("%d_%m_%Y")
def _keyboard_press(self, key):
item = [self._current_time(), str(key), self.mouse.position]
self.events_list_array.append(item)
def _mouse_press(self, x, y, button, pressed):
self.mouse_count += 1
if self.mouse_count % 5 == 0:
self._is_game_over()
self.mouse_count = 0
item = [self._current_time(), str(button), (x, y)]
self.events_list_array.append(item)
def _is_game_over(self):
self.game_object.is_game_still_in_proggress()
if self.game_object.is_game_procces_active == False:
self.listener_on(False)
def save(self):
#check data
if len(self.events_list_array) == 0:
raise Exception("No data recorded")
print(self.events_list_array)
return self.events_list_array, self.start_time
#keyboard
def on_press(self, key):
self._keyboard_press(key)
def on_release(self, key):
pass
#mouse
def on_move(self, x, y):
pass
def on_click(self, x, y, button, pressed):
if pressed:
self._mouse_press(x, y, button, pressed)
else:
pass
def on_scroll(self, x, y, dx, dy):
pass
