-
Notifications
You must be signed in to change notification settings - Fork 0
/
5 w 1 v1.3.py.bak
323 lines (274 loc) · 11 KB
/
5 w 1 v1.3.py.bak
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
"""
Z - chodzi
C - trzyma RMB
X - trzyma LMB
F - klika szybko LMB (1500 klinięć na sekundę)
F7 - scroll up (przybliża ekran)
F8 - scroll down (odsuwa ekran)
G - chodzi w kółko (widok powinien być od góry inaczej będzie chodził po większym promieniu)
[ - klika szybko Q i E
R - trzyma E
T - trzyma E przez 3 sekundy, puszcza i znowu trzyma przez 3 sekundy (loop)
V - skacze (spacja)
O tym czy dana opcja jest włączona (ON) czy wyłączona (OFF) informuje w swoim okienku
"""
from pynput import keyboard
from pynput.keyboard import Controller as KeyboardController
from pynput.keyboard import Key
from pynput.mouse import Controller as MouseController
from pynput.mouse import Button
import threading
import time
# 01 - Trzymanie 'W' i spacji (ruch do przodu i skakanie)
class KeySimulator:
def __init__(self):
self.w_pressed = False
self.space_pressed = False
self.keyboard_controller = KeyboardController()
# 01a - Klawisz 'W'
def toggle_w(self):
if not self.w_pressed:
self.keyboard_controller.press('w')
self.w_pressed = True
print("\nChodzenie: ON \n(aby wyłączyć naciśnij 'Z')")
else:
self.keyboard_controller.release('w')
self.w_pressed = False
print("Chodzenie: OFF")
# 01b - Spacja
def toggle_space(self):
if not self.space_pressed:
self.keyboard_controller.press(Key.space)
self.space_pressed = True
print("\nSpacja: ON \n(aby wyłączyć naciśnij 'V')")
else:
self.keyboard_controller.release(Key.space)
self.space_pressed = False
print("Spacja: OFF")
# 02 - Akcje przycisków myszy
class MouseActionSimulator:
def __init__(self):
self.mouse_controller = MouseController()
self.hold_lmb_thread = None
self.hold_rmb_thread = None
self.click_thread = None
self.holding_lmb = False
self.holding_rmb = False
self.clicking = False
# 02a - Trzymanie LMB
def toggle_hold_lmb(self):
if self.holding_lmb:
self.holding_lmb = False
if self.hold_lmb_thread and self.hold_lmb_thread.is_alive():
self.hold_lmb_thread.join()
print("LMB Hold: OFF")
else:
self.holding_lmb = True
self.hold_lmb_thread = threading.Thread(target=self.hold_lmb, daemon=True)
self.hold_lmb_thread.start()
print("\nLMB Hold: ON \n(aby wyłączyć naciśnij 'X')")
def hold_lmb(self):
self.mouse_controller.press(Button.left)
while self.holding_lmb:
time.sleep(0.01)
self.mouse_controller.release(Button.left)
# 02b - Trzymanie RMB
def toggle_hold_rmb(self):
if self.holding_rmb:
self.holding_rmb = False
if self.hold_rmb_thread and self.hold_rmb_thread.is_alive():
self.hold_rmb_thread.join()
print("RMB Hold: OFF")
else:
self.holding_rmb = True
self.hold_rmb_thread = threading.Thread(target=self.hold_rmb, daemon=True)
self.hold_rmb_thread.start()
print("\nRMB Hold: ON \n(aby wyłączyć naciśnij 'C')")
def hold_rmb(self):
self.mouse_controller.press(Button.right)
while self.holding_rmb:
time.sleep(0.01)
self.mouse_controller.release(Button.right)
# 02c - Klikanie 1500 kliknięć na sekundę
def toggle_click_lmb(self):
if self.clicking:
self.clicking = False
if self.click_thread and self.click_thread.is_alive():
self.click_thread.join()
print("LMB Click fast: OFF")
else:
self.clicking = True
self.click_thread = threading.Thread(target=self.click_lmb, daemon=True)
self.click_thread.start()
print("\nLMB Click fast: ON \n(aby wyłączyć naciśnij 'F')")
def click_lmb(self):
clicks_per_second = 100 # było 1500
interval = 1.0 / clicks_per_second
while self.clicking:
self.mouse_controller.click(Button.left)
time.sleep(interval)
# 03down - Scroll down (oddalanie ekranu)
class ScrollSimulator:
def __init__(self):
self.scrolling = False
self.mouse_controller = MouseController()
self.scroll_thread = None
def toggle_scroll_down(self):
self.scrolling = not self.scrolling
if self.scrolling:
threading.Thread(target=self.scroll_down, daemon=True).start()
print("\nOddalenie ekranu: ON \n(aby wyłączyć naciśnij 'F8')")
else:
print("Oddalenie ekranu: OFF")
def scroll_down(self):
while self.scrolling:
self.mouse_controller.scroll(0, -1) # Scroll down
time.sleep(0.1)
# 03up - Scroll up (przybliżanie ekranu)
def toggle_scroll_up(self):
self.scrolling = not self.scrolling
if self.scrolling:
threading.Thread(target=self.scroll_up, daemon=True).start()
print("\nPrzybliżenie ekranu: ON \n(aby wyłączyć naciśnij 'F7')")
else:
print("Przybliżenie ekranu: OFF")
def scroll_up(self):
while self.scrolling:
self.mouse_controller.scroll(0, 1) # Scroll up
time.sleep(0.1)
# 04 - Sekwencja chodzenia
class KeySequenceSimulator:
def __init__(self):
self.active = False
self.keyboard_controller = KeyboardController()
self.thread = None
def toggle_simulation(self):
if not self.active:
self.active = True
if self.thread is None or not self.thread.is_alive():
self.thread = threading.Thread(target=self.simulate_key_sequence)
self.thread.start()
print("\nChodzenie dookoła: ON \n(aby wyłączyć naciśnij 'G')")
else:
print("\nChodzenie dookoła: OFF \n(zaraz przestanie chodzić)")
self.active = False
if self.thread and self.thread.is_alive():
self.thread.join()
def simulate_key_sequence(self):
keys = ['w', 's', 'a', 'd']
while self.active:
for key in keys:
time.sleep(0.1)
if not self.active:
break
self.keyboard_controller.press(key)
if key == 'd':
time.sleep(5) # Trzymanie każdego innego klawisza przez 1 sekundę
self.keyboard_controller.release(key)
# 05 - Spamowanie Q+E oraz trzymanie E
class KeyboardActions:
def __init__(self):
self.holding_e = False
self.clicking_qe = False
self.hold_e_thread = None # Zmienione z False na None, aby wskazywać brak wątku
self.click_qe_thread = None # Podobnie jak wyżej
self.keyboard_controller = keyboard.Controller()
# 05a - Trzymanie E
def toggle_hold_e(self):
if self.holding_e:
self.holding_e = False
if self.hold_e_thread and self.hold_e_thread.is_alive():
self.hold_e_thread.join()
print("Trzymanie E: OFF")
else:
self.holding_e = True
self.hold_e_thread = threading.Thread(target=self.hold_e, daemon=True)
self.hold_e_thread.start()
print("\nTrzymanie E: ON \n(aby wyłączyć naciśnij 'R')")
# To jest trzymanie klawisza 'E' wciśniętego
def hold_e(self):
self.keyboard_controller.press('e') # Naciśnij 'e' na początku
while self.holding_e:
time.sleep(0.1) # Utrzymuj pętlę, ale bez ciągłego naciskania 'e'
self.keyboard_controller.release('e') # Puść 'e', gdy self.holding_e będzie False
# 05b - Trzymanie E przez 3 sekundy (loop)
def toggle_hold_e_loop(self):
if self.holding_e:
self.holding_e = False
if self.hold_e_thread and self.hold_e_thread.is_alive():
self.hold_e_thread.join()
print("Pętla E: OFF")
else:
self.holding_e = True
self.hold_e_thread = threading.Thread(target=self.hold_e_loop, daemon=True)
self.hold_e_thread.start()
print("\nPętla E: ON \n(aby wyłączyć naciśnij 'T')")
# Trzymanie klawisza 'E' wciśniętego przez 3 sekundy (loop)
def hold_e_loop(self):
while self.holding_e:
self.keyboard_controller.press('e') # Naciśnij 'e'
time.sleep(3) # Trzymaj 'e' przez 3 sekundy
self.keyboard_controller.release('e') # Puść 'e'
if not self.holding_e: # Sprawdź, czy pętla powinna zostać zatrzymana
break
time.sleep(0.1) # Krótka przerwa przed ponownym naciśnięciem 'e'
# 05c - Spamowanie Q+E
def toggle_click_qe(self):
if self.clicking_qe:
self.clicking_qe = False
if self.click_qe_thread and self.click_qe_thread.is_alive():
self.click_qe_thread.join()
print("Spam Q+E: OFF")
else:
self.clicking_qe = True
self.click_qe_thread = threading.Thread(target=self.click_qe, daemon=True)
self.click_qe_thread.start()
print("\nSpam Q+E: ON \n(aby wyłączyć naciśnij '[')")
def click_qe(self):
while self.clicking_qe:
self.keyboard_controller.press('q')
self.keyboard_controller.release('q')
time.sleep(0.01)
self.keyboard_controller.press('e')
self.keyboard_controller.release('e')
time.sleep(0.01)
key_simulator = KeySimulator()
mouse_action_simulator = MouseActionSimulator()
scroll_simulator = ScrollSimulator()
key_sequence_simulator = KeySequenceSimulator()
keyboard_actions = KeyboardActions()
def on_press(key):
# Trzymanie W i spacji
if key == keyboard.KeyCode.from_char('z'):
key_simulator.toggle_w()
elif key == keyboard.KeyCode.from_char('v'):
key_simulator.toggle_space()
# Akcje klawiszami myszy
elif hasattr(key, 'char') and key.char in ['x', 'f', 'c']:
if key.char == 'x':
mouse_action_simulator.toggle_hold_lmb()
elif key.char == 'f':
mouse_action_simulator.toggle_click_lmb()
elif key.char == 'c':
mouse_action_simulator.toggle_hold_rmb()
# Scroll down F8
elif key == keyboard.Key.f8:
scroll_simulator.toggle_scroll_down()
# Scroll down F7
elif key == keyboard.Key.f7:
scroll_simulator.toggle_scroll_up()
# Chodzenie
elif key == keyboard.KeyCode.from_char('g'):
key_sequence_simulator.toggle_simulation()
# Trzymanie E
elif key == keyboard.KeyCode.from_char('r'):
keyboard_actions.toggle_hold_e()
# Trzymanie E przez 3 sekundy (loop)
elif key == keyboard.KeyCode.from_char('t'):
keyboard_actions.toggle_hold_e_loop()
# Spamowanie Q+E
elif key == keyboard.KeyCode.from_char('['):
keyboard_actions.toggle_click_qe()
# Listener for key presses
with keyboard.Listener(on_press=on_press) as listener:
listener.join()