def key_up(self, key):
if key == Key.up:
self.keys['a'] = False
elif key == Key.down:
self.keys['down'] = False
elif key == Key.left:
self.keys['left'] = False
elif key == Key.right:
self.keys['right'] = False
elif key == Key.space:
self.keys['up'] = False
elif key == KeyCode.from_char('c'):
self.keys['r'] = False
elif key == Key.enter:
self.keys['r'] = False
self.keys['l'] = False
elif key == KeyCode.from_char('a'):
self.left = False
elif key == KeyCode.from_char('d'):
self.right = False
elif key == KeyCode.from_char('w'):
self.up = False
elif key == KeyCode.from_char('s'):
self.down = False
def test_parse_valid(self):
self.assertSequenceEqual(
HotKey.parse('a'),
[
kc.from_char('a')])
self.assertSequenceEqual(
HotKey.parse('A'),
[
kc.from_char('a')])
self.assertSequenceEqual(
HotKey.parse('<ctrl>+a'),
[
k.ctrl,
kc.from_char('a')])
self.assertSequenceEqual(
HotKey.parse('<ctrl>+<alt>+a'),
[
k.ctrl,
k.alt,
kc.from_char('a')])
self.assertSequenceEqual(
HotKey.parse('<ctrl>+<123456>'),
[
k.ctrl,
kc.from_vk(123456)])
def key_down(self, key):
global direction
if key == Key.up:
self.keys['a'] = True
elif key == Key.down:
self.keys['down'] = True
elif key == Key.left:
self.keys['left'] = True
elif key == Key.right:
self.keys['right'] = True
elif key == Key.space:
self.keys['up'] = True
elif key == KeyCode.from_char('c'):
self.keys['r'] = True
elif key == Key.enter:
# press both R and L
self.keys['r'] = True
self.keys['l'] = True
elif key == KeyCode.from_char('a'): # left
self.left = True
elif key == KeyCode.from_char('d'): # right
self.right = True
elif key == KeyCode.from_char('w'): # up
self.up = True
elif key == KeyCode.from_char('s'): # down
self.down = True
elif key == Key.esc:
# quit
return False
def __init__(self):
self.snooze = 0
try:
f = open(self.FILE_NAME, 'r')
for line in f:
#exclude the last line
if (len(line) != 0):
if (line.split('=')[0] == 'endPassword'):
self.muteHotKey = []
for element in line.split('=')[1].split('\n')[0]:
self.muteHotKey.append(KeyCode.from_char(element))
elif (line.split('=')[0] == 'configHotKey'):
self.configHotKey = []
for element in line.split('=')[1].split('\n')[0]:
self.configHotKey.append(
KeyCode.from_char(element))
else:
self.reminderTime = int(
line.split('=')[1].split('\n')[0])
f.close()
except:
self.writeToFile()
self.isRunning = True
self.startTime = time.localtime()
self.sleeper = sleep.Sleep(1)
def on_press(self, key):
print(key)
self.directions = [False for _ in range(4)]
self.signal_stop = False
# use arrow keys to drive, space key to stop
# feel free to add more keys
if key == Key.up:
self.directions[0] = True
elif key == Key.down:
self.directions[1] = True
elif key == Key.left:
self.directions[2] = True
elif key == Key.right:
self.directions[3] = True
elif key == Key.space:
self.signal_stop = True
elif key == KeyCode.from_char('i'):
self.toggle = not self.toggle
elif key == KeyCode.from_char('o'):
if (self.toggle):
self.wheel_vel_forward -= 10
else:
self.wheel_vel_rotation -= 10
elif key == KeyCode.from_char('p'):
if (self.toggle):
self.wheel_vel_forward += 10
else:
self.wheel_vel_rotation += 10
self.send_drive_signal()
class KeyListener:
key_mapping = {
KeyCode.from_char('a'): "LEFT",
KeyCode.from_char('d'): "RIGHT",
KeyCode.from_char('w'): "UP",
KeyCode.from_char("s"): "DOWN",
Key.space: "FIRE"
}
def __init__(self, env):
# meaning = env.unwrapped.get_action_meanings()
# self.meaning_to_action = dict(zip(meaning, list(range(len(meaning)))))
# self.time_between_frames = 0.1
# self.current_act = self.meaning_to_action["NOOP"]
pass
def on_press(self, key):
print(key)
print(key == KeyCode.from_char("a"))
print(key == Key.space)
# if key in self.key_mapping:
# self.current_act = self.meaning_to_action[self.key_mapping[key]]
# elif key == "+":
# self.time_between_frames /= 2
# elif key == "-":
# self.time_between_frames *= 2
def on_release(self, key):
# if key in self.key_mapping:
# self.current_act = self.meaning_to_action["NOOP"]
if key == Key.esc:
return False
def handle_key_pressed(self, keys_to_check: list, pressed_keys: list,
current_vel: float) -> float:
new_vel = current_vel
positive_axis_press = KeyCode.from_char(
keys_to_check[0]) in pressed_keys
negative_axis_press = KeyCode.from_char(
keys_to_check[1]) in pressed_keys
if positive_axis_press and negative_axis_press:
return new_vel
if positive_axis_press:
return round(number=float(
np.clip(new_vel + 1, -self.maxmin_vel, self.maxmin_vel)),
ndigits=2)
if negative_axis_press:
return round(number=float(
np.clip(new_vel - 1, -self.maxmin_vel, self.maxmin_vel)),
ndigits=2)
# nothing is pressed, smoothly lowering the value
return round(number=float(
np.clip(new_vel * 0.75, -self.maxmin_vel, self.maxmin_vel)),
ndigits=2)
def on_release(self, key):
if key == (KeyCode.from_char(chr(list(self.pitch.keys())[0]))):
self.releaseFlagPitch = True
return False
elif key == (KeyCode.from_char(chr(list(self.modulation.keys())[0]))):
self.releaseFlagModu = True
return False
class KeyListener:
key_mapping = {
KeyCode.from_char('a'): "LEFT",
KeyCode.from_char('d'): "RIGHT",
KeyCode.from_char('w'): "UP",
KeyCode.from_char("s"): "DOWN",
Key.space: "FIRE"
}
def __init__(self, env):
meaning = env.unwrapped.get_action_meanings()
self.meaning_to_action = dict(zip(meaning, list(range(len(meaning)))))
self.time_between_frames = 0.1
self.current_act = self.meaning_to_action["NOOP"]
def on_press(self, key):
if key in self.key_mapping and self.key_mapping[
key] in self.meaning_to_action:
self.current_act = self.meaning_to_action[self.key_mapping[key]]
elif key == KeyCode.from_char("+"):
self.time_between_frames /= 2
elif key == KeyCode.from_char("-"):
self.time_between_frames *= 2
def on_release(self, key):
if key in self.key_mapping and self.key_mapping[
key] in self.meaning_to_action:
self.current_act = self.meaning_to_action["NOOP"]
if key == Key.esc:
return False
def on_release(self, key):
if key == keyboard.Key.enter: # click
self.get_a_credit()
elif key == KeyCode.from_char('a'):
print("List of achievements:")
print([
key if achievement_list[key] else "???"
for key in achievement_list
])
elif key == KeyCode.from_char('h'):
print('''List of commands:
h (help): display this message
a (achievements): view achievements
Enter: click
Esc: quit game''')
elif key == KeyCode.from_char('c'):
print("Nan, pour cliquer faut juste faire entrée sans rien écrire")
elif key == keyboard.Key.esc: # exit game
self.game_over = True
return False
else:
print("Invalid command. Did you mean \"c\" (click)?")
def test_activate_single(self):
activations = []
def on_activate():
activations.append(True)
hk = HotKey({kc.from_char('a')}, on_activate)
hk.press(kc.from_char('b'))
self.assertEqual(0, len(activations))
hk.release(kc.from_char('b'))
self.assertEqual(0, len(activations))
hk.press(kc.from_char('a'))
self.assertEqual(1, len(activations))
hk.release(kc.from_char('a'))
self.assertEqual(1, len(activations))
hk.press(kc.from_char('a'))
self.assertEqual(2, len(activations))
hk.press(kc.from_char('a'))
self.assertEqual(2, len(activations))
hk.release(kc.from_char('a'))
self.assertEqual(2, len(activations))
hk.press(kc.from_char('A'))
self.assertEqual(3, len(activations))
hk.release(kc.from_char('A'))
self.assertEqual(3, len(activations))
def move_leap_motion_visualizer(self):
subprocess.Popen([self.path_leap_folder, '-new-tab'])
time.sleep(0.1)
# # [LEAP MOTION VISUALIZER] - moving window
user32 = ctypes.windll.user32
# get screen resolution of primary monitor
res = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
# res is (2293, 960) for 3440x1440 display at 150% scaling
user32.SetProcessDPIAware()
res = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
# res is now (3440, 1440) for 3440x1440 display at 150% scaling
handle = user32.FindWindowW(None, u'Leap Motion Diagnostic Visualizer')
user32.ShowWindow(handle, 6)
user32.ShowWindow(handle, 9)
user32.ShowWindow(handle, 1)
user32.MoveWindow(handle, 5, 0, 705, 620, True)
print("Moving Leap Motion Visualizer on predefined position")
for i in range(3):
self.keyboard.press('v')
self.keyboard.release('v')
for i in range(5):
self.keyboard.press(KeyCode.from_char('='))
self.keyboard.release(KeyCode.from_char('='))
self.keyboard.press('c')
self.keyboard.release('c')
self.keyboard.press('g')
self.keyboard.release('g')
def on_press(key):
#print('{0} pressed'.format(key))
if key == KeyCode.from_char('w'):
print 'forward'
robot_con(1, 1, 0, 0)
elif key == KeyCode.from_char('x'):
print 'Backward'
robot_con(-1, -1, 0, 0)
elif key == KeyCode.from_char('a'):
print 'Left'
robot_con(0, 0, -1, -1)
elif key == KeyCode.from_char('d'):
print 'Right'
robot_con(0, 0, 1, 1)
elif key == KeyCode.from_char('q'):
print 'Top Left'
robot_con(1, 1, -1, -1)
elif key == KeyCode.from_char('e'):
print 'Top Right'
robot_con(1, 1, 1, 1)
elif key == KeyCode.from_char('c'):
print 'Bottom Left'
robot_con(-1, -1, 1, 1)
elif key == KeyCode.from_char('z'):
print 'Bottom Right'
robot_con(-1, -1, -1, -1)
elif key == KeyCode.from_char('f'):
print 'anti-clockwise'
robot_con(0.5, -0.5, -0.5, 0.5)
elif key == KeyCode.from_char('g'):
print 'clockwise'
robot_con(-0.5, 0.5, 0.5, -0.5)
def do_action(action: str, cfg: Config = None) -> bool:
if action.startswith('##'):
do_meta_action(action, cfg)
return True
else:
tokens = action.split('+')
for token in tokens:
if (token.startswith("mouse")):
mouse_cmd: str = token.split('.')[1]
tokens.remove(token)
if mouse_cmd.startswith("move"):
coords = mouse_cmd.replace("move(", "").replace(")", "").split(',')
m_pos = mouse.position
coords = get_coords(int(coords[0]), int(coords[1]))
mouse.move(coords[0] - m_pos[0], coords[1] - m_pos[1])
elif mouse_cmd == "rclick":
mouse.click(ms.Button.right, 1)
elif mouse_cmd == "lclick":
mouse.click(ms.Button.left, 1)
else:
controller.press(getattr(Key, token, KeyCode.from_char(token)))
for token in reversed(tokens):
controller.release(getattr(Key, token, KeyCode.from_char(token)))
return False
def on_release(key):
print('{0} release'.format(key))
if key == KeyCode.from_char("1"):
mouse.click(Button.left)
if key == KeyCode.from_char("2"):
mouse.click(Button.right)
if key == Key.esc:
pass
def on_press(key):
nonlocal action
# print(key)
if key == KeyCode.from_char('a'):
action = -max_action
# print("go left")
if key == key == KeyCode.from_char('d'):
action = max_action
def testOnKeyBadKeys(self):
buff = deque(maxlen=4)
self.handler.onkey(KeyCode.from_char('a'), buff)
self.handler.onkey(Key.alt, buff)
self.handler.onkey(KeyCode.from_char('b'), buff)
self.handler.onkey(KeyCode.from_char('c'), buff)
self.handler.onkey(KeyCode.from_char('d'), buff)
self.assertEqual(4, len(buff))
def on_press(self, key):
client = SimpleUDPClient(self.client_ip, self.client_port)
if key == (KeyCode.from_char(chr(list(self.pitch.keys())[0]))):
out = self.updatePitch(key_status='on')
client.send_message("/outputs/" + out[0], out[1])
elif key == (KeyCode.from_char(chr(list(self.modulation.keys())[0]))):
out = self.updateModulation(key_status='on')
client.send_message("/outputs/" + out[0], out[1])
def resetMouse():
mouse.position = (-1300, -1300)
print('Mouse reset')
#reset the text area, so we don't get differences between loads and run throughs
keyboard.press(KeyCode.from_char('N'))
keyboard.release(KeyCode.from_char('N'))
global currentMov
currentMov = [0, 0]
def testOnKeyBadKeys(self):
buff = deque(maxlen=4)
self.handler.onkey(KeyCode.from_char("a"), buff)
self.handler.onkey(Key.alt, buff)
self.handler.onkey(KeyCode.from_char("b"), buff)
self.handler.onkey(KeyCode.from_char("c"), buff)
self.handler.onkey(KeyCode.from_char("d"), buff)
self.assertEqual(4, len(buff))
def on_press(self, key):
if key in self.key_mapping and self.key_mapping[
key] in self.meaning_to_action:
self.current_act = self.meaning_to_action[self.key_mapping[key]]
elif key == KeyCode.from_char("+"):
self.time_between_frames /= 2
elif key == KeyCode.from_char("-"):
self.time_between_frames *= 2
def on_release(key):
if KeyCode.from_char("q") == key:
print("Quit")
global finished
finished = True
elif KeyCode.from_char("s") == key:
global record
record = True
def shortcut(s):
if s.endswith('-'):
s = s[:-2]
key = KeyCode.from_char('-')
else:
s = s.rsplit('-', maxsplit=1)
s, key = ''.join(s[:-1]), s[-1]
key = getattr(Key, key, KeyCode.from_char(key))
return tuple(getattr(Key, k) for k in s.split('-') if k) + (key, )
def on_press(key):
print('{0} pressed'.format(key))
if key == KeyCode.from_char('w'):
time.sleep(2)
if key == KeyCode.from_char('w'):
num = random.randrange(0, 10, 1)
if num > 7:
keyboard.press('a')
if num < 3:
keyboard.press('d')
def on_press(key):
#print '{0} pressed'.format(key)
if key == KeyCode.from_char('w') or key == Key.up:
car.forward()
if key == KeyCode.from_char('s') or key == Key.down:
car.backward()
if key == KeyCode.from_char('a') or key == Key.left:
car.left()
if key == KeyCode.from_char('d') or key == Key.right:
car.right()
def on_release(key):
nonlocal action
if key == key == KeyCode.from_char('a'):
action = 0
# print("stop")
if key == key == KeyCode.from_char('d'):
action = 0
# print('stop')
if key == Key.esc:
# Stop listener
return False
def testOnKeyFullBuff(self):
buff = deque(maxlen=4)
self.handler.onkey(KeyCode.from_char("a"), buff)
self.handler.onkey(KeyCode.from_char("b"), buff)
self.handler.onkey(KeyCode.from_char("c"), buff)
self.handler.onkey(KeyCode.from_char("d"), buff)
self.handler.onkey(KeyCode.from_char("e"), buff)
self.assertEqual(4, len(buff))
self.assertEqual("b", buff.popleft())
self.assertEqual("c", buff.popleft())
self.assertEqual("d", buff.popleft())
self.assertEqual("e", buff.popleft())
def testOnKeyFullBuff(self):
buff = deque(maxlen=4)
self.handler.onkey(KeyCode.from_char('a'), buff)
self.handler.onkey(KeyCode.from_char('b'), buff)
self.handler.onkey(KeyCode.from_char('c'), buff)
self.handler.onkey(KeyCode.from_char('d'), buff)
self.handler.onkey(KeyCode.from_char('e'), buff)
self.assertEqual(4, len(buff))
self.assertEqual('b', buff.popleft())
self.assertEqual('c', buff.popleft())
self.assertEqual('d', buff.popleft())
self.assertEqual('e', buff.popleft())
def on_press(self, key):
print(key)
# use arrow keys to drive, space key to stop
# feel free to add more keys
if key == Key.up:
self.directions[1] = False
self.directions[0] = True
elif key == Key.down:
self.directions[0] = False
self.directions[1] = True
elif key == Key.left:
self.directions[3] = False
self.directions[2] = True
elif key == Key.right:
self.directions[2] = False
self.directions[3] = True
elif key == Key.space:
self.directions = [False for _ in range(4)]
self.signal_stop = True
elif key == KeyCode.from_char('a'):
print("Speed up")
self.wheel_vel_forward += 10
elif key == KeyCode.from_char('d'):
print("Speed down")
self.wheel_vel_forward -= 10
# Stop everything before next action
'''
if key == Key.up:
self.directions = [False for _ in range(4)]
self.directions[0] = True
elif key == Key.down:
self.directions = [False for _ in range(4)]
self.directions[1] = True
elif key == Key.left:
self.directions = [False for _ in range(4)]
self.directions[2] = True
elif key == Key.right:
self.directions = [False for _ in range(4)]
self.directions[3] = True
elif key == Key.space:
self.signal_stop = True
elif key == KeyCode.from_char('a'):
print("Speed up")
self.wheel_vel_forward += 10
elif key == KeyCode.from_char('d'):
print("Speed down")
self.wheel_vel_forward -= 10
'''
self.send_drive_signal()
def on_release(key):
if key == KeyCode.from_char("a"):
counter.handleRealtime("in", 1, "a", "released")
if key == KeyCode.from_char("s"):
counter.handleRealtime("in", 1, "b", "released")
if key == KeyCode.from_char("z"):
counter.handleRealtime("out1", 1, "a", "released")
if key == KeyCode.from_char("x"):
counter.handleRealtime("out1", 1, "b", "released")
if key == Key.esc:
# Stop listener
return False
