def _key_callback(self, symbol, modifiers, event_time):
# check the key and time (if this is needed)
keys = val(self.keys)
correct_resp = val(self.correct_resp)
sym_str = key.symbol_string(symbol)
if None in keys or sym_str in keys:
# it's all good!, so save it
self.pressed = sym_str
self.press_time = event_time
# fill the base time val
self.base_time = val(self.base_time_src)
if self.base_time is None:
# set it to the state time
self.base_time = self.state_time
# calc RT if something pressed
self.rt = event_time['time']-self.base_time
if self.pressed in correct_resp:
self.correct = True
# let's leave b/c we're all done
#self.interval = 0
self.leave()
def on_key_release(self, inp, modifers):
if symbol_string(inp) == "LEFT":
self.sprite.dx = 0
print("release left, dx:", self.sprite.dx)
if symbol_string(inp) == "RIGHT":
self.sprite.dx = 0
print("release right, dx:", self.sprite.dx)
def on_key_release(self, inp, modifers):
if symbol_string(inp) == "LEFT":
self.sprite.dx = 0
print("release left, dx:", self.sprite.dx)
if symbol_string(inp) == "RIGHT":
self.sprite.dx = 0
print("release right, dx:", self.sprite.dx)
def on_key_press(self, key, modif):
move_left = MoveBy((-50, 0), .5)
if symbol_string(key) == "LEFT":
self.sprite.do(move_left)
if symbol_string(key) == "RIGHT":
self.sprite.do(Reverse(move_left))
def on_key_release(self, key, modifiers):
if symbol_string(key) == "RIGHT":
self.rotation_speed -= 90
elif symbol_string(key) == "LEFT":
self.rotation_speed += 90
elif symbol_string(key) == "UP":
self.power_on = False
def load(self):
with io.open(KEYMAP_FILE, 'rt', encoding='utf-8') as f:
game_options = False
for l in f:
if '#' in l:
game_options = True
continue
if game_options:
semi = l.find(';')
name = l[:semi]
val = int(l[semi + 1:])
self.key_map[name] = val
self.game.keybind_menu.controls[
name + ' key'].text = Pkey.symbol_string(val)
else:
semi = l.find(';')
name = l[:semi]
val = int(l[semi + 1:])
self.game.keybind_menu.controls[
name + ' key'].text = Pkey.symbol_string(val)
player_n = int(name[7])
name = name[9:]
self.player_map[str(player_n)][name] = val
if not val in self.keys:
self.keys[val] = False
def draw(self):
super().draw()
drawLabel("Increment size: {}".format(self.increment), self.width // 2,
self.height - 12, self.textSize)
plusSymbol = key.symbol_string(self.incrementPlusKey)
minusSymbol = key.symbol_string(self.incrementMinusKey)
drawLabel("{} - /10 Increment {} - x10 Increment".format(
plusSymbol, minusSymbol),
self.width // 2,
5,
self.textSize - 2,
anchorY="bottom")
index = 0
for i in settings:
offsetY = (index * 25)
index += 1
drawLabel("{}: {}".format(settings[i][1], settings[i][0]),
self.textOffsetX + 10,
self.height - 60 - offsetY,
self.textSize,
anchorX='left',
anchorY='bottom')
def save_exp(self, rest_time=1):
name = inspect.getouterframes(inspect.currentframe())[1][1] #get the file path that called save_exp
name = name.rsplit('/')[-1].rsplit('.')[0] #get its name without '.py'
self.names.append(name)
# experiment class
self.curr_experiment.name = name
# there is at least one test, so
# this is not a rest file, so assign a key
if self.curr_experiment.tests != []:
self.experiments.append(self.curr_experiment)
ind = len(self.experiments)-1
curr_key = [key._1, key._2, key._3, key._4, key._5,
key._6, key._7, key._8, key._9][ind]
if ind<=8:
self.window.add_key_action(curr_key, self.begin_experiment, ind)
if ind==0: print '\nScheduler key assignments:'
print key.symbol_string(curr_key) + ' - ' + name
# since this is not a test file and there is at least one
# rest, add it to rests and make it the default rest
elif self.curr_experiment.rest != []:
self.rests.append(self.curr_experiment)
print 'rest - ' + name
self.curr_experiment = None #clear it for the next save
def on_key_press(symbol, modifiers):
if key.symbol_string(symbol) == 'SPACE':
environment.active = not environment.active
if key.symbol_string(symbol) == 'S':
environment.mode = 'S'
if key.symbol_string(symbol) == 'C':
environment.mode = 'C'
def on_key_press(self, symbol, modifiers):
import p5.globals
from pyglet.window import key
try:
if modifiers == 0:
p5.globals.keycode.set(ord(key.symbol_string(symbol)))
else:
p5.globals.keycode.set(None)
except TypeError:
p5.globals.keycode.set(None)
p5.globals.key.set(key.symbol_string(symbol).replace("_", ""))
if modifiers != 0:
p5.globals.modifiers.set(
key.modifiers_string(modifiers).replace("|", ",").replace(
"MOD_", ""))
else:
p5.globals.modifiers.set(None)
p5.globals.keyispressed.set(True)
try:
self.KeyPressed()
except AttributeError:
pass
if modifiers == 0:
try:
self.KeyTyped()
except AttributeError:
pass
def test_certain_modifier_key_presses_do_not_change_state(self):
app = MockApp()
state = dispatcher.init_state(dispatcher.default_state, app, None)
state.send(NormalEvent(ON_KEY_PRESS, pkey.M))
current_state = state.gi_frame.f_locals['current_state']
self.assertEqual(current_state.__name__, 'marking')
keys = [
pkey.LSHIFT, pkey.RSHIFT,
pkey.LCTRL, pkey.RCTRL,
pkey.CAPSLOCK,
pkey.LMETA, pkey.RMETA,
pkey.LALT, pkey.RALT,
pkey.LWINDOWS, pkey.RWINDOWS,
pkey.LCOMMAND, pkey.RCOMMAND,
pkey.LOPTION, pkey.ROPTION
]
for key in keys:
state.send(NormalEvent(ON_KEY_PRESS, key))
current_state = state.gi_frame.f_locals['current_state']
self.assertIsNotNone(current_state,
msg="{} has changed the state".format(pkey.symbol_string(key)))
self.assertEqual(current_state.__name__, 'marking',
msg="current_state was changed by {}".format(pkey.symbol_string(key)))
def on_key_release(self, key, modifiers):
if symbol_string(key) != "RETURN":
self.keys_pressed.remove(key)
if symbol_string(key) == "SPACE":
if self.accel.isPlaying:
self.accel.stop()
self.snake.speed = 180
def on_key_press(self, key, modifiers):
if symbol_string(key) == "T":
self.do(Twirl(amplitude=5, duration=2))
elif symbol_string(key) == "W":
self.do(Reverse(Waves(duration=2)))
elif symbol_string(key) == "F":
self.do(FlipX3D(duration=1) + FlipY3D(duration=1) + Reverse(FlipY3D(duration=1)))
def on_key_press(self, key, modifiers):
if symbol_string(key) == "RIGHT":
self.rotation_speed += 90
elif symbol_string(key) == "LEFT":
self.rotation_speed -= 90
elif symbol_string(key) == "UP":
self.power_on = True
elif symbol_string(key) == "SPACE":
self.shoot()
def on_key_press(self, key, modifiers): if symbol_string(key) == 'LEFT': pass if symbol_string(key) == "RIGHT": pass if symbol_string(key) == "ESCAPE": self.backToPrevious() if symbol_string(key) == "SPACE": self.print_options() pass
def _is_correct_key(self, symbol):
if not self.chosen_symbol:
self.fail_test('No more key presses/releases expected.')
return False
if self.chosen_symbol != symbol:
self.fail_test('Received key "{}", but expected "{}"'.format(key.symbol_string(symbol),
key.symbol_string(self.chosen_symbol)))
return False
return True
def on_key_press(self, key, modifiers):
if symbol_string(key) == "T":
self.do(Twirl(amplitude=5, duration=2))
elif symbol_string(key) == "W":
self.do(Reverse(Waves(duration=2)))
elif symbol_string(key) == "F":
self.do(
FlipX3D(duration=1) + FlipY3D(duration=1) +
Reverse(FlipY3D(duration=1)))
def on_key_release(self, symbol, modifiers):
letter = key.symbol_string(symbol)
if self.verbose: print("release:",letter,key.modifiers_string(modifiers))
_keyboard.remove(key.symbol_string(symbol))
if self.keyrelease is not None:
kwargs = {
"window":self,
"symbol":key.symbol_string(symbol),
"modifiers":key.modifiers_string(modifiers)
}
self.keyrelease(**kwargs)
def on_key_press(self, symbol, modifiers):
letter = key.symbol_string(symbol)
if self.verbose:
print("press:",letter,key.modifiers_string(modifiers))
_keyboard.add(key.symbol_string(symbol))
if self.keypress is not None:
kwargs = {
"window":self,
"symbol":key.symbol_string(symbol),
"modifiers":key.modifiers_string(modifiers)
}
self.keypress(**kwargs)
def on_key_press(self, symbol, modifiers):
letter = key.symbol_string(symbol)
if self.verbose:
print("press:", letter, key.modifiers_string(modifiers))
_keyboard.add(key.symbol_string(symbol))
if self.keypress is not None:
kwargs = {
"window": self,
"symbol": key.symbol_string(symbol),
"modifiers": key.modifiers_string(modifiers)
}
self.keypress(**kwargs)
def on_key_press(self, key, modifiers):
try:
if self.active:
num = int(symbol_string(key)[-1])
self.inputLabel.element.text = self.inputLabel.element.text + symbol_string(
key)[-1]
if len(self.inputLabel.element.text) > (self.charLimit - 1):
self.active = False
self.bgImage.image = pyglet.resource.image("textBox.png")
self.changed = True
except ValueError:
pass
def on_key_release(self, symbol, modifiers):
letter = key.symbol_string(symbol)
if self.verbose: print("release:",letter,key.modifiers_string(modifiers))
_keyboard.remove(key.symbol_string(symbol))
if self.keyrelease is not None:
kwargs = {
"window":self,
"symbol":key.symbol_string(symbol),
"modifiers":key.modifiers_string(modifiers)
}
self.keyrelease(**kwargs)
def _direct_mode(self, symbol, modifiers):
if symbol == key.COLON:
self._set_command(':')
elif symbol_string(symbol) in Moves.keys():
command = symbol_string(symbol)
commands = self.cube.create_commands(command)
self._execute(commands, invert=modifiers & key.MOD_SHIFT)
self._set_command('')
elif symbol in Macros.keys():
commands = self.cube.create_commands(Macros[symbol])
self._execute(commands, invert=modifiers & key.MOD_SHIFT)
self._set_command('')
def on_key_release(symbol, modifiers):
if key.symbol_string(
symbol).lower() == 'enter' and self._act is not None:
print("Human input disabled.")
self.openai_inputs_queue = []
elif key.symbol_string(symbol).lower() in self.keys:
next_openai_input = [
self.action_indices[str([[
spaces.KeyEvent.by_name(
key.symbol_string(symbol).lower(), down=False)
]])]
]
self.push_action_to_queue(next_openai_input)
self.last_input_was_mouse_motion = False
def on_key_press(self, key, modifiers):
# First I create a move action because we programmers are lazy and hate having to retype code!
move_left = MoveBy((-50, 0), .5)
# Here's where that Pyglet symbol_string() function comes in handy
# Rather than having to interpret an inconsistent code, I can simply interpret the word LEFT and RIGHT
if symbol_string(key) == "LEFT":
self.sprite.do(move_left)
# Now I need to tell the layer what to do if the user inputs RIGHT
if symbol_string(key) == "RIGHT":
# This is a pretty awesome feature built into Cocos
# I only wrote code for moving left, but I can use the Reverse() function instead of rewriting code
# Reverse() simply tells Cocos to do the reverse action of whatever you pass into it.
self.sprite.do(Reverse(move_left))
def on_key_release(self, symbol, modifiers):
print('Release: ', key.symbol_string(symbol))
symbol = self._handle_meta_release(symbol)
if symbol not in self.active_keys:
self.fail_test('Released key "{}" was not pressed before.'.format(key.symbol_string(symbol)))
else:
self.active_keys.remove(symbol)
if len(self.active_keys) == 0 and self.completely_pressed:
self.completely_pressed = False
self.checks_passed += 1
if self.checks_passed == self.number_of_checks:
self.pass_test()
else:
self._select_next_key()
def on_key_press(self, key, modifiers):
if symbol_string(key) == "ENTER":
self.handle_answer()
else:
print(key - ord('0'))
self.answer += chr(key)
self.answer_label.element.text = self.answer
def on_key_press(self, symbol, modifiers):
if pymterm.debug_log:
LOGGER.debug('on_key_press:{}, {}'.format(
key.symbol_string(symbol),
key.modifiers_string(modifiers)))
key_state = KeyState(symbol, modifiers)
if symbol == key.Q and \
(modifiers == key.MOD_COMMAND or modifiers == key.MOD_CTRL):
self.close()
return
if self.session.terminal.process_key(key_state):
if pymterm.debug_log:
LOGGER.debug(' processed by pyterm')
return
v, handled = term.term_keyboard.translate_key(self.session.terminal,
key_state)
if len(v) > 0:
self.session.send(v)
self._key_first_down = True
def get_key_string(self, value):
value = key.symbol_string(value)
if value.startswith('_'):
value = value[1:]
if value == 'LCTRLREAL':
return 'LCTRL'
return value
def get_key_string(self, value):
value = key.symbol_string(value)
if value.startswith('_'):
value = value[1:]
if value == 'LCTRLREAL':
return 'LCTRL'
return value
def __init__(self, gui, data, align_x, align_y, padding):
self.gui = gui
self.data = data
self.align_x = align_x
self.align_y = align_y
self.padding = padding
self._index = 0
self.check_sprite = pyglet.sprite.Sprite(
graphics.img.gui_radio_check, batch=gui.batch, group=graphics.group.gui_front)
self.check_sprite.scale = self.sprite_scale
self.sprites = []
self.labels = []
for symbol, caption in self.data:
text = "[{}] ".format(key.symbol_string(symbol))
text += caption
sprite = pyglet.sprite.Sprite(
graphics.img.gui_radio,
batch=gui.batch,
group=graphics.group.gui_mid)
sprite.opacity = 127
sprite.scale = self.sprite_scale
label = pyglet.text.Label(
text,
font_size=11, bold=False,
anchor_y="center",
color=(255, 255, 255, 127),
batch=gui.batch,
group=graphics.group.gui_front)
self.sprites.append(sprite)
self.labels.append(label)
gui.app.window.push_handlers(self.on_resize, self.on_key_press, self.on_mouse_press)
def on_key_release(self, key, modifiers):
k = symbol_string(key)
status = False
if k == "LEFT":
self.key_pressed_left = status
elif k == "RIGHT":
self.key_pressed_right = status
def print_keypress_actions(self):
items = sorted(self.keypress_actions.items())
for keypress, action in items:
keysymbol = key.symbol_string(keypress[0]).lstrip(' _')
modifiers = key.modifiers_string(keypress[1]).replace('MOD_', '').replace('|', ' ').lstrip(' ')
func, args, kwargs = action[0].__name__, action[1], action[2]
print('{:<10} {:<6} --- {:<30}({}, {})'.format(modifiers, keysymbol, func, args, kwargs))
def key(self, symbol, modifiers):
""" Key pressed event handler.
"""
if symbol == key.F1:
self.mode = 1
self.default()
print "Projection: Pyglet default"
if symbol == key.NUM_0:
global correction_rmatrix1, zero_rmatrix, rmatrix1
correction_rmatrix1 = np.dot(zero_rmatrix, np.linalg.inv(rmatrix1))
elif symbol == key.F2:
print "Projection: 3D Isometric"
self.mode = 2
self.isometric()
elif symbol == key.F3:
print "Projection: 3D Perspective"
self.mode = 3
self.perspective()
elif self.mode == 3 and symbol == key.NUM_SUBTRACT:
self.fov -= 1
self.perspective()
elif self.mode == 3 and symbol == key.NUM_ADD:
self.fov += 1
self.perspective()
else:
print "KEY " + key.symbol_string(symbol)
def on_key_press(self, symbol, modifiers):
""" Handles key presses in/for menus and toggling fps display """
if symbol == key.F and not self.game_state == AsteroidGameStates.GAME_OVER:
self.show_fps = not self.show_fps
if self.game_state == AsteroidGameStates.MAIN_MENU or \
self.game_state == AsteroidGameStates.PAUSED or \
self.game_state == AsteroidGameStates.TOP_SCORES:
menu = None
menu_name = None
if self.game_state == AsteroidGameStates.MAIN_MENU:
menu = self.main_menu
menu_name = 'main'
elif self.game_state == AsteroidGameStates.PAUSED:
menu = self.pause_menu
menu_name = 'pause'
elif self.game_state == AsteroidGameStates.TOP_SCORES:
menu = self.top_score_menu
menu_name = 'top score'
if symbol == key.DOWN:
self.move_menu_select(menu, 1)
elif symbol == key.UP:
self.move_menu_select(menu, -1)
elif symbol == key.ENTER:
self.handle_menu_press(
self.selected_menu_text(menu), menu_name)
if symbol == key.ESCAPE and self.game_state == AsteroidGameStates.PLAYING:
self.game_state = AsteroidGameStates.PAUSED
elif symbol == key.ESCAPE and self.game_state == AsteroidGameStates.PAUSED:
self.game_state = AsteroidGameStates.PLAYING
if symbol == key.ENTER and self.game_state == AsteroidGameStates.GAME_OVER:
self.game_state = AsteroidGameStates.MAIN_MENU
# reset game objects
self.score = 0
self.level = 1
self.game_batch = pyglet.graphics.Batch()
self.game_objects, \
self.player_ship, \
self.asteroids = self.create_game_objects(self.game_batch)
self.game_label_batch = pyglet.graphics.Batch()
self.player_lives, \
self.score_label, \
self.level_label = self.create_game_labels(self.game_label_batch)
elif self.game_state == AsteroidGameStates.GAME_OVER:
self.player_name[self.player_name_input_index] = \
key.symbol_string(symbol)[0]
self.player_name_input_index += 1
self.player_name_input_index %= 3
self.game_over_name_label.text = \
'%s %s %s' % (
self.player_name[0],
self.player_name[1],
self.player_name[2],
)
def save_exp(self):
name = inspect.getouterframes(inspect.currentframe())[1][1] #get the file path that called save_exp
name = name.rsplit('/')[-1].rsplit('.')[0] #get its name without '.py'
self.names.append(name)
self.exps.append(self.tests)
self.tests = []
ind = len(self.exps)-1
curr_key = [key._1, key._2, key._3, key._4, key._5,
key._6, key._7, key._8, key._9][ind]
if ind<=8:
self.window.add_key_action(curr_key, self.print_exp, ind)
self.window.add_key_action(curr_key, self.load_exp, ind)
self.window.add_key_action(curr_key, self.begin, True)
if ind==0: print '\nScheduler key assignments:'
print key.symbol_string(curr_key) + ' - ' + name
def on_key_press(self, key, modifiers):
k = symbol_string(key)
status = True
if k == "LEFT":
self.key_pressed_left = status
elif k == "RIGHT":
self.key_pressed_right = status
elif k == "SPACE" and self.life == 1:
if self.jump_count > 0:
x, y = self.sprite.position
try:
self.remove(self.jump1)
except:
pass
# jump效果图
self.jump1 = Sprite("images/jump.png")
self.jump1.opacity = 250
self.jump1.position = (x, y-100)
self.add(self.jump1)
self.jump_speed = 20
self.jump_y = y
self.key_pressed_up = True
self.jump_count -= 1
elif k == "DOWN":
self.key_pressed_down = status
elif k == "SPACE" and self.life == 0:
scene = Scene(GameLayer())
director.replace(SplitColsTransition(scene))
def onKeyPressHandler(p_key, p_mods):
"""
:param p_key:
:param p_mods:
"""
format_str = 'Key pressed: "{}" mods: {}'
char = key.symbol_string(p_key)
label.text = format_str.format(char, p_mods)
def on_key_press(self, key, modifiers):
self.keys_pressed.add(key)
self.snake.update_angle(self.keys_pressed)
#按下空格蛇加速
if symbol_string(key) == "SPACE":
self.accel.play(-1)
self.accel.isPlaying = True
self.snake.speed = 300
def on_mouse_release(self, x, y, key, m):
k = symbol_string(key)
status = False
if k == '1':
self.page_is_pressing = status
self.mouse_press_left = status
elif k == '4':
self.mouse_press_right = status
def on_mouse_release(self, x, y, key, m):
k = symbol_string(key)
status = False
if k == '1':
self.page_is_pressing = status
self.mouse_press_left = status
elif k == '4':
self.mouse_press_right = status
def on_key_press(self, symbol, modifiers):
print 'Pressed %s with modifiers %s' % \
(key.symbol_string(symbol), key.modifiers_string(modifiers))
if symbol == key.E:
exclusive = not (modifiers & key.MOD_SHIFT)
self.w.set_exclusive_keyboard(exclusive)
print 'Exclusive keyboard is now %r' % exclusive
def on_key_press(self, key, m):
k = symbol_string(key)
if k == 'S': # 按S键保存
self.save_file('levelfile/level'+str(self.save_as)+'.txt', self.blocks)
self.reset_level_select()
self.saveflag.element.text = '已保存'
elif k == 'P': # 按P键开始游戏
scenes = Scene(main.Background(), main.Start())
director.replace(SplitColsTransition(scenes))
def on_key_press(self, key, mi):
k = symbol_string(key)
if (k == 'R') or (k == 'C'):
if k == 'R':
scene = Scene(GameLayer())
elif k == 'C':
print(1)
scene = Scene(GameLayer(self.levels, self.gold, self.deadcount))
director.replace(scene)
def on_key_press(self, key, modifiers):
k = symbol_string(key)
status = True
if k == 'LEFT':
self.key_pressed_left = status
elif k == 'RIGHT':
self.key_pressed_right = status
elif k == 'UP':
self.key_pressed_up = status
def on_key_press(self, key, mi):
k = symbol_string(key)
print(k)
if k =='S':
scenes = Scene(GuoCangDongHua())
director.replace(SplitColsTransition(scenes))
elif k == 'E':
scenes = Scene(editor.Editor())
director.replace(SplitColsTransition(scenes))
def on_key_release(self, key, modifiers):
k = symbol_string(key)
print('release', k)
if k == "LEFT":
self.key_pressed_left = False
if k == "RIGHT":
self.key_pressed_right = False
if k == "UP":
self.key_pressed_up = False
def on_key_press(self, symbol, modifiers):
volume = self.song.get_volume()
if symbol_string(symbol) == "LEFT" and volume > 0.0:
volume = round(volume - 0.1, 1)
if symbol_string(symbol) == "RIGHT" and volume < 1.0:
volume = round(volume + 0.1, 1)
self.song.set_volume(volume)
if symbol == key.LEFT:
self.idx = max(0, self.idx - 1)
elif symbol == key.RIGHT:
self.idx = min(len(self.items) - 1, self.idx + 1)
if symbol in (key.LEFT, key.RIGHT, key.ENTER):
self.item.text = self._get_label()
self.item_selected.text = self._get_label()
self.callback_func(self.idx)
return True
def on_key_press(self, key, m):
k = symbol_string(key)
print(k)
if k == 'S':
self.save_file('levelfile/level1.txt', self.pos)
self.saveflag.element.text = '已保存'
elif k == 'P':
scenes = Scene(main.Start())
director.replace(SplitColsTransition(scenes))
def on_key_press(self, key, modifiers): k = symbol_string(key) status = True if k == "LEFT": self.key_pressed_left = status elif k == "RIGHT": self.key_pressed_right = status elif k == "UP": self.key_pressed_up = status
def _is_correct_modifier_key(self, symbol):
modifier = self._get_modifier_for_key(symbol)
if modifier == 0:
return False
if not self.chosen_modifiers & modifier:
self.fail_test('Unexpected modifier key "{}"'.format(key.symbol_string(symbol)))
return True
def _update_question(self):
self.question = """Please hold <Shift> and press:
{} ({})
Press Esc if test does not pass.""".format(key.motion_string(self.chosen_key),
key.symbol_string(self.chosen_key))
self._render_question()
def on_key_press(self, key, modifiers):
k = symbol_string(key)
if k == "UP":
self.j -= 1
if self.j < 0:
self.j = 0
if self.j == 2:
self.label1.element.text = "纸醉金迷"
elif self.j == 1:
self.label1.element.text = "交易赌局"
elif self.j == 0:
self.label1.element.text = "金钱崇拜"
elif k == "DOWN":
self.j += 1
if self.j > 2:
self.j = 2
if self.j == 2:
self.label1.element.text = "纸醉金迷"
elif self.j == 1:
self.label1.element.text = "交易赌局"
elif self.j == 0:
self.label1.element.text = "金钱崇拜"
elif k == "LEFT":
self.i -= 1
if self.i < 0:
self.i = 0
if self.i == 2:
self.label.element.text = "爷爷"
elif self.i == 1:
self.label.element.text = "爸爸"
elif self.i == 0:
self.label.element.text = "老公"
self.remove(self.sprite)
self.sprite = Sprite(role_choose[self.i])
self.sprite.position = (500, 450)
self.add(self.sprite)
elif k == "RIGHT":
self.i += 1
if self.i > 2:
self.i = 2
if self.i == 2:
self.label.element.text = "爷爷"
elif self.i == 1:
self.label.element.text = "爸爸"
elif self.i == 0:
self.label.element.text = "老公"
self.remove(self.sprite)
self.sprite = Sprite(role_choose[self.i])
self.sprite.position = (500, 450)
self.add(self.sprite)
elif k == "SPACE":
global choose_i, choose_j
choose_i = self.i
choose_j = self.j
print(choose_i)
scene = Scene(GameLayer())
director.replace(SplitColsTransition(scene))
def on_key_press(self, key, mi):
if self.is_on_exiting:
k = symbol_string(key)
if (k == 'R') or (k == 'C'):
self.is_on_exiting = False
if k == 'R':
scene = create_scene(Start())
elif k == 'C':
scene = create_scene(GameLayer(self.hud))
director.replace(SplitColsTransition(scene))
def _on_pyglet_keypress(self, symbol, modifiers, emulated=False):
"""Handler for on_key_press pyglet events"""
key_time = clock()
if emulated:
this_key = str(symbol)
else:
from pyglet.window import key
this_key = key.symbol_string(symbol).lower()
this_key = this_key.lstrip('_').lstrip('NUM_')
self._keyboard_buffer.append((this_key, key_time))
def save_exp(self, rest_time=1):
name = inspect.getouterframes(inspect.currentframe())[1][1] #get the file path that called save_exp
name = name.rsplit('/')[-1].rsplit('.')[0] #get its name without '.py'
if name == 'rest': #the stimulus between experiments
self.rest.append(self.tests)
else: #regular experiment
self.names.append(name)
self.exps.append(self.tests)
self.tests = [[]] #the first inner parens for the rest procedure
ind = len(self.exps)-1
curr_key = [key._1, key._2, key._3, key._4, key._5,
key._6, key._7, key._8, key._9][ind]
if ind<=8:
self.window.add_key_action(curr_key, self.print_exp, ind)
self.window.add_key_action(curr_key, self.load_exp, ind)
self.window.add_key_action(curr_key, self.begin, True)
if ind==0: print '\nScheduler key assignments:'
print key.symbol_string(curr_key) + ' - ' + name
