def main():
"""Main program loop"""
pygame.init()
screen = pygame.display.set_mode(opt.window_size)
sys_font = Font(get_default_font(), opt.font_size)
clock = Clock()
manager = YarsManager()
running = True
while running:
#limit framerate and prepare FPS display text
clock.tick(opt.max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white)
if event.get(pygame.QUIT):
sys.exit()
running = manager.handle_events(event.get(), key.get_pressed())
manager.update()
screen.fill(opt.black)
manager.draw(screen)
screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width))
pygame.display.update()
sys.exit()
def checkInput(p):
global joyin, joystick_count
xaxis = yaxis = 0
if joystick_count > 0:
xaxis = joyin.get_axis(0)
yaxis = joyin.get_axis(1)
if key.get_pressed()[K_LEFT] or xaxis < -0.8:
p.angle = 180
p.movex = -20
if key.get_pressed()[K_RIGHT] or xaxis > 0.8:
p.angle = 0
p.movex = 20
if key.get_pressed()[K_UP] or yaxis < -0.8:
p.angle = 90
p.movey = -20
if key.get_pressed()[K_DOWN] or yaxis > 0.8:
p.angle = 270
p.movey = 20
#initialisez input function
# inside update() function
if player.movex or player.movey:
inputLock()
animate(player, pos=(player.x + player.movex, player.y + player.movey), duration=1/SPEED, tween='linear', on_finished=inputUnLock)
def input(self, event):
self.x_speed = 0.0
self.y_speed = 0.0
x, y = mouse.get_pos()
if event.type == MOUSEBUTTONDOWN and event.button == MOUSE.MIDDLE:
self.x_first = x
self.y_first = y
elif event.type == MOUSEBUTTONUP and event.button == MOUSE.MIDDLE:
self.x_first = None
self.y_first = None
elif event.type == MOUSEMOTION and mouse.get_pressed()[1] and \
self.x_first and self.y_first:
self.x_delta = x - self.x_first
self.y_delta = y - self.y_first
else:
if mouse.get_focused():
if x > self.w - self.scroll_width and x < self.w:
self.x_speed = self.speed
elif x < self.scroll_width:
self.x_speed = -self.speed
if y > self.h - self.scroll_width:
self.y_speed = self.speed
elif y < self.scroll_width:
self.y_speed = -self.speed
if key.get_focused():
if key.get_pressed()[K_RIGHT]:
self.x_speed = self.speed
elif key.get_pressed()[K_LEFT]:
self.x_speed = -self.speed
if key.get_pressed()[K_DOWN]:
self.y_speed = self.speed
elif key.get_pressed()[K_UP]:
self.y_speed = -self.speed
def check_inputs_movement_ship(self):
if get_pressed()[K_a] or get_pressed()[K_LEFT]:
if self._can_move_left():
self._move_ship_left()
if get_pressed()[K_d] or get_pressed()[K_RIGHT]:
if self._can_move_right():
self._move_ship_right()
def update(self):
# Implement some basic controls
self.vx += self.accel * (key.get_pressed()[self.keys['right']] -
key.get_pressed()[self.keys['left']])
self.vy += self.gravity - self.accel * key.get_pressed()[
self.keys['up']]
self.x += self.vx
self.y += self.vy
self.collide()
def manual_control(self):
# Ici vous mettez votre logique de mouvement, avec les touches de clavier etc.
if key.get_pressed()[K_UP]:
self.pos.y -= 0.2
if self.pos.y < 0:
self.pos.y = 0
if key.get_pressed()[K_DOWN]:
self.pos.y += 0.2
if self.pos.y > (self.screen.get_height() - 50):
self.pos.y = self.screen.get_height() - 50
self.rect = Rect((self.pos.x, self.pos.y), (5, 100))
def manual_control(self):
# Ici vous mettez votre logique de mouvement, avec les touches de clavier etc.
if key.get_pressed()[K_UP]:
if self.rect.y <= 0:
self.rect.y = 0
else:
self.rect.y -= 1 * self.speed
if key.get_pressed()[K_DOWN]:
if self.rect.y >= self.screen.get_height() - 100:
self.rect.y = self.screen.get_height() - 100
else:
self.rect.y += 1 * self.speed
return
def get(self):
events.pump()
notmine = []
inp = NOOP
for event in events.get():
if event.type == QUIT:
inp = QUITCOMMAND
if ((event.type == KEYDOWN or event.type == KEYUP)
and self.keyDict.has_key(event.key)):
if event.type == KEYDOWN:
inp = self.keyDict[event.key]
elif event.type == KEYUP:
keyDown = key.get_pressed()
if (keyDown[self.commandDict[UP]]):
inp = UP
elif (keyDown[self.commandDict[DOWN]]):
inp = DOWN
elif (keyDown[self.commandDict[LEFT]]):
inp = LEFT
elif (keyDown[self.commandDict[RIGHT]]):
inp = RIGHT
else:
inp = STOP
else:
raise UnexpectedInput
else:
notmine.append(event)
for yours in notmine:
events.post(yours)
return inp
def processKeysAndActions(state, dt):
keys = list(key.get_pressed())
if(glob.joystick):
for f in glob.joystickKeys:
if f():
keys[glob.Keys.currentKeys[glob.joystickKeys.index(f)]] = 1
return state.processActions(keys, dt)
def on_execute(self):
global game_state
if self.on_init() is False:
self._running = False
# run and unload loading screen
su.game_state = su.GameState.LOADING
self.loading_screen.run(self._display_surf)
self.loading_screen = None
# Displays intro message
fb.show_info_feedback(WELCOME)
su.game_state = su.GameState.MAIN_LOOP
while (self._running and su.game_state == su.GameState.MAIN_LOOP):
event.pump()
keys = key.get_pressed()
self.on_event(keys, event)
self.on_loop()
self.on_render()
if su.game_state == su.GameState.WON:
self.game_won()
self.on_cleanup()
def handle_keyboard_events(self):
"""
set quit as true if user presses ESCAPE key
"""
keys = key.get_pressed()
if keys[K_q] or keys[K_ESCAPE]:
self.quit = True
def update(self, delta):
pressed_keys = get_pressed()
# Direction
direction_vector = Vector2()
direction_vector.y = pressed_keys[K_DOWN] - pressed_keys[K_UP]
direction_vector.x = pressed_keys[K_RIGHT] - pressed_keys[K_LEFT]
if direction_vector.length() != 0:
direction_vector.normalize_ip()
# Speed
if direction_vector.magnitude() > 0:
if self.speed.magnitude() < self.max_speed * delta / 1000.0:
self.speed += direction_vector * self.acceleration \
* delta/1000.0
else:
self.speed = direction_vector * self.max_speed * delta / 1000.0
elif self.speed.magnitude() > 1:
self.speed += self.speed.normalize() * -self.friction \
* delta/1000.0
else:
self.speed = self.speed * 0
# Movement
self.rect.move_ip(*self.speed)
# Keep player on the screen
self.rect.left = max(0, self.rect.left)
self.rect.right = min(self.screen_w, self.rect.right)
self.rect.top = max(0, self.rect.top)
self.rect.bottom = min(self.screen_h, self.rect.bottom)
# Update collider
self.update_box_collider()
def update(self, time):
# Move position
self.x, self.y = self.x + (self.velocity[0] * time), self.y + (self.velocity[1] * time)
# Check new rotation
mouse_pos = mouse.get_pos()
facing = mouse_pos[0] - self.x, mouse_pos[1] - self.y
length = math.hypot(*facing)
self.facing = facing[0] / length, facing[1] / length
# Rotate Image
self.image = pygame.transform.rotate(player_image, math.degrees(math.atan2(*self.facing)))
self.rect = self.image.get_rect()
self.rect.center = int(self.x), int(self.y)
# If off screen, move to other side
if self.rect.bottom < self.screen.top:
self.rect.top = self.screen.bottom
elif self.rect.top > self.screen.bottom:
self.rect.bottom = self.screen.top
if self.rect.right < self.screen.left:
self.rect.left = self.screen.right
elif self.rect.left > self.screen.right:
self.rect.right = self.screen.left
self.x, self.y = self.rect.center
# Accelerate
key = keyboard.get_pressed()
if key[self.thruster]:
x = self.velocity[0] + (self.facing[0] * self.acceleration * time)
y = self.velocity[1] + (self.facing[1] * self.acceleration * time)
self.velocity = x, y
def handle_keyboard_events(self): """ set quit as true if user presses ESCAPE key """ keys = key.get_pressed() if keys[K_q] or keys[K_ESCAPE]: self.quit = True
def input_string(self, prompt, x, y):
# Draw a prompt string in the window using the current font
# and colors. Check keys pressed by the user until an enter
# key is pressed and return the sequence of key presses as a
# str object.
# - self is the Window
# - prompt is the str to display
# - x is the int x coord of the upper left corner of the
# string in the window
# - y is the int y coord of the upper left corner of the
# string in the window
key = K_SPACE
answer = ''
while key != K_RETURN:
self.draw_string(prompt + answer + ' ', x, y)
if not self.__auto_update__:
update()
key = self._get_key()
key_state = get_pressed()
if (K_SPACE <= key <= K_z):
if key == K_SPACE:
letter = ' '
else:
letter = name(key)
if key_state[K_LSHIFT] or key_state[K_RSHIFT] or key_state[
K_CAPSLOCK]:
letter = letter.upper()
answer = answer + letter
if key == K_BACKSPACE:
answer = answer[0:len(answer) - 1]
return answer
def update(self):
if self.life > 0:
keys = key.get_pressed()
if keys[K_LEFT] and self.rect.x > 5:
self.rect.x -= self.speed
if keys[K_RIGHT] and self.rect.x < win_width - 80:
self.rect.x += self.speed
def start_loop():
(w, h) = SCREEN_CENTER
textpos2 = (w, h + FONT_SIZE + 20)
text1 = font.render('ASTEROIDS', 1, COLOR.WHITE)
text2 = font.render('Press Enter', 1, COLOR.WHITE)
textpos1 = text1.get_rect(center=SCREEN_CENTER)
textpos2 = text2.get_rect(center=textpos2)
waiting = True
while waiting:
for event in get_events():
if event.type == QUIT:
raise SystemExit('Thanks for playing!')
keys = get_pressed()
if keys[K_RETURN]:
return
screen.blit(background, (0, 0))
screen.blit(text1, textpos1)
screen.blit(text2, textpos2)
display.update()
clock.tick(FPS)
def update(self):
if self.button_list:
keys = pgk.get_pressed()
if keys[pl.K_TAB] == 1 and self.last_key != pl.K_TAB:
self.focused_button_index += 1
self.last_key = pl.K_TAB
if self.focused_button_index >= len(self.button_list):
self.focused_button_index = 0
print(self.button_list[self.focused_button_index].name)
if keys[pl.
K_RETURN] == 1 and self.focused_button_index > -1 and self.last_key != pl.K_RETURN:
self.button_list[self.focused_button_index].clicked_on(1)
self.last_key = pl.K_RETURN
if not keys[pl.K_TAB] and not keys[pl.K_RETURN]:
self.last_key = None
for element in self.elements:
if element.visible:
element.update()
self.surface.blit(element.image, element.rect)
if self.click != 0 and element.rect.collidepoint(
pygame.mouse.get_pos()):
element.clicked_on(self.click)
def update(self) -> Optional[Scene]:
# self.screen.zoom = 1 + cos(time.get_ticks() / 500) / 2
# print(self.screen.get_game_pos(mouse.get_pos()))
keys = key.get_pressed()
# Update zoom if zoom keys are pressed
if keys[K_PLUS] or keys[K_EQUALS]:
self.zoom_pow += 0.1
self.screen.zoom = 2**self.zoom_pow
elif keys[K_MINUS] or keys[K_UNDERSCORE]:
self.zoom_pow -= 0.1
self.screen.zoom = 2**self.zoom_pow
# Update the position
vec = Vec2(0, 0)
if keys[K_RIGHT]: vec += Vec2(1, 0)
if keys[K_LEFT]: vec += Vec2(-1, 0)
if keys[K_UP]: vec += Vec2(0, 1)
if keys[K_DOWN]: vec += Vec2(0, -1)
# Move a constant distance in the direction specified
# Proportional to the screen zoom
vec.set_length(0.05 * (2**-self.zoom_pow))
self.screen.pos += vec
# Update the circle position
self.theta = (time.get_ticks() / 500) % (2 * pi)
pass
def update(self, time):
keys = key.get_pressed()
if keys[pygame.K_LEFT]:
self.character.dir = characters.DIR_LEFT
elif keys[pygame.K_RIGHT]:
self.character.dir = characters.DIR_RIGHT
def read(self):
if self.serial:
try:
return self.serial.read()
except serial.SerialException:
self.serial = None
pressed = get_pressed()
if pressed[K_1]:
return b'1'
elif pressed[K_2]:
return b'2'
elif pressed[K_3]:
return b'3'
elif pressed[K_4]:
return b'4'
elif GPIO.input(gpio_button_red):
# GPIO.output(gpio_led_red, GPIO.HIGH)
return b'1'
elif GPIO.input(gpio_button_green):
# GPIO.output(gpio_led_green, GPIO.HIGH)
return b'2'
elif GPIO.input(gpio_button_blue):
# GPIO.output(gpio_led_blue, GPIO.HIGH)
return b'3'
elif GPIO.input(gpio_button_yellow):
# GPIO.output(gpio_led_yellow, GPIO.HIGH)
return b'4'
return b''
def keyboard_routines(self):
'''
Run the specified keyboard routine based upon the operand. These
operations are:
Es9E - SKPR Vs
EsA1 - SKUP Vs
0x9E will check to see if the key specified in the source register is
pressed, and if it is, skips the next instruction. Operation 0xA1 will
again check for the specified keypress in the source register, and
if it is NOT pressed, will skip the next instruction. The register
calculations are as follows:
Bits: 15-12 11-8 7-4 3-0
unused source 9 or A E or 1
'''
operation = self.operand & 0x00FF
source = (self.operand & 0x0F00) >> 8
key_to_check = self.registers['v'][source]
keys_pressed = key.get_pressed()
# Skip if the key specified in the source register is pressed
if operation == 0x9E:
if keys_pressed[KEY_MAPPINGS[key_to_check]]:
self.registers['pc'] += 2
# Skip if the key specified in the source register is not pressed
if operation == 0xA1:
if not keys_pressed[KEY_MAPPINGS[key_to_check]]:
self.registers['pc'] += 2
def game_loop():
"""Ciclo de juego. Mientras no se cierre la ventana, el juego no
termina."""
pantalla = set_mode((ANCHO, ALTO))
set_caption("Pong <3")
fondo = cargar_imagen('images/fondo_pong.png')
bola = Bola()
pala = Pala(30, imagen="images/amlo.jpg")
pala_cpu = Pala(ANCHO - 30, 0.3, "images/trump.jpg")
clock = Clock()
puntos = [0, 0]
sonido = Sound('audios/Tetris.ogg')
sonido.play()
while puntos[0] < 30 and puntos[1] < 30:
time = clock.tick(60)
keys = get_pressed()
for eventos in get():
if eventos.type == QUIT:
sys.exit(0)
bola.actualizar(time, pala, pala_cpu, puntos)
pala.mover(time, keys)
pala_cpu.ia(time, bola)
puntos_jug, puntos_jug_rect = texto(
"Jugador Puntos: " + str(puntos[0]), 140, 40)
puntos_cpu, puntos_cpu_rect = texto(
"Maquina Puntos: " + str(puntos[1]), ANCHO - ANCHO / 4, 40)
pantalla.blit(fondo, (0, 0))
pantalla.blit(bola.image, bola.rect)
pantalla.blit(pala.image, pala.rect)
pantalla.blit(pala_cpu.image, pala_cpu.rect)
pantalla.blit(puntos_jug, puntos_jug_rect)
pantalla.blit(puntos_cpu, puntos_cpu_rect)
flip()
return 0
def end_loop():
(w, h) = SCREEN_CENTER
textpos2 = (w, h + FONT_SIZE + 20)
text1 = font.render('Play Again?', 1, COLOR.WHITE)
text2 = font.render('Press Enter', 1, COLOR.WHITE)
textpos1 = text1.get_rect(center=SCREEN_CENTER)
textpos2 = text2.get_rect(center=textpos2)
waiting = True
while waiting:
for event in get_events():
if event.type == QUIT:
raise SystemExit('Thanks for playing!')
keys = get_pressed()
if keys[K_RETURN]:
return True
screen.blit(background, (0, 0))
# Draw score in top left
text = font.render(str(Asteroid.number_destroyed), 1, COLOR.WHITE)
screen.blit(text, (10, 10))
screen.blit(text1, textpos1)
screen.blit(text2, textpos2)
display.update()
clock.tick(FPS)
return False
def update(self, time):
keys = key.get_pressed()
if keys[pygame.K_LEFT]:
self.character.left(time)
elif keys[pygame.K_RIGHT]:
self.character.right(time)
def check_input():
global joy_in, joystick_count
x_axis = y_axis = 0
if joystick_count > 0:
x_axis = joy_in.get_axis(0)
y_axis = joy_in.get_axis(1)
move_x = move_y = 0
if key.get_pressed()[K_LEFT] or x_axis < -0.8:
move_x = -1
if key.get_pressed()[K_RIGHT] or x_axis > 0.8:
move_x = 1
if key.get_pressed()[K_UP] or y_axis < -0.8:
move_y = -1
if key.get_pressed()[K_DOWN] or y_axis > 0.8:
move_y = 1
return move_x, move_y
def update(self):
if self.item_grab:
self.item.equanto_pego(self)
self.move(get_pressed())
if self.parar == 3:
if self.item_grab:
self.current_sprites = self.grab_item_run_sprites
else:
self.current_sprites = self.run_sprites
self.sprite_change += 0.1
self.parar -= 0.5
if self.parar <= 0:
if self.item_grab:
self.current_sprites = self.grab_item_idle_sprite
else:
self.current_sprites = self.idle_sprites
if self.sprite_change >= len(self.current_sprites):
self.sprite_change = 0
self.image = flip(self.current_sprites[int(self.sprite_change)],
self.flipped, False)
self.pos_x = [True, True]
self.pos_y = [True, True]
self.colision_check()
def get(self):
events.pump()
notmine = []
inp = NOOP
for event in events.get():
if event.type == QUIT:
inp = QUITCOMMAND
if ((event.type == KEYDOWN or event.type == KEYUP)
and self.keyDict.has_key(event.key)):
if event.type == KEYDOWN:
inp = self.keyDict[event.key]
elif event.type == KEYUP:
keyDown = key.get_pressed()
if(keyDown[self.commandDict[UP]]):
inp = UP
elif(keyDown[self.commandDict[DOWN]]):
inp = DOWN
elif(keyDown[self.commandDict[LEFT]]):
inp = LEFT
elif(keyDown[self.commandDict[RIGHT]]):
inp = RIGHT
else:
inp = STOP
else:
raise UnexpectedInput
else:
notmine.append(event)
for yours in notmine:
events.post(yours)
return inp
def keyboard_routines(self):
"""
Run the specified keyboard routine based upon the operand. These
operations are:
Es9E - SKPR Vs
EsA1 - SKUP Vs
0x9E will check to see if the key specified in the source register is
pressed, and if it is, skips the next instruction. Operation 0xA1 will
again check for the specified keypress in the source register, and
if it is NOT pressed, will skip the next instruction. The register
calculations are as follows:
Bits: 15-12 11-8 7-4 3-0
unused source 9 or A E or 1
"""
operation = self.operand & 0x00FF
source = (self.operand & 0x0F00) >> 8
key_to_check = self.registers['v'][source]
keys_pressed = key.get_pressed()
# Skip if the key specified in the source register is pressed
if operation == 0x9E:
if keys_pressed[KEY_MAPPINGS[key_to_check]]:
self.registers['pc'] += 2
# Skip if the key specified in the source register is not pressed
if operation == 0xA1:
if not keys_pressed[KEY_MAPPINGS[key_to_check]]:
self.registers['pc'] += 2
def move(self):
"""Moves the player.
Return Value:
None"""
keys = pgk.get_pressed()
# Applies force to the players physical body
self.jumping = False
dx, dy = 0, 0
if keys[pl.
K_UP] == 1 and self.can_jump and self.body.linearVelocity.y < self.max_jump_speed:
dy += 1
self.jumping = True
if keys[pl.
K_RIGHT] == 1 and self.body.linearVelocity.x < self.max_run_speed:
dx += 1
elif keys[
pl.
K_LEFT] == 1 and self.body.linearVelocity.x > -self.max_run_speed:
dx -= 1
self.body.ApplyLinearImpulse(
impulse=(dx * self.body.mass * self.run_force,
dy * self.body.mass * self.jump_force),
point=(self.body.position.x, self.body.position.y),
wake=True)
if dx != 0 or dy != 0:
print(self.rect.x, self.rect.y)
def run(self):
print "\nCalibration program.\n"
print "Press 'c' to enter a calibration point.\n\n"
while not rospy.is_shutdown():
# update gauges
norm_pan_rad = math.radians(self.normalize_pan(self.get_pan()))
norm_tilt_rad = math.radians(self.normalize_tilt(self.get_tilt()))
self.update_display(norm_pan_rad, norm_tilt_rad)
pygame.event.pump()
keys = key.get_pressed()
# pan = pan + inc_pan
# if pan > math.pi or pan < 0:
# inc_pan = -inc_pan
# tilt = tilt + inc_tilt
# if tilt > math.pi or tilt < 0:
# inc_tilt = -inc_tilt
pan = self.get_normalized_pan()
tilt = self.get_normalized_tilt()
self.screen.fill(pygame.Color(0, 0, 0))
self.widgets['pan'].set_pan(pan)
self.widgets['pan'].draw(self.screen, 0, 0)
self.widgets['tilt'].set_tilt(tilt)
self.widgets['tilt'].draw(self.screen, 200, 0)
pygame.display.flip()
if keys[pygame.K_ESCAPE]:
return
self.rate.sleep()
def KBRD(self):
"""
Runs the correct keyboard routine based on CurrentOperand
OPERANDS:
ES9E - SKPR VS (IF KEY IN VS IS PRESSED, SKIP LINE)
ESA1 - SKUP VS (IF KEY IN VS NOT PRESSED, SKIP LINE)
"""
# Formatting operation for lookup table (get first 2 bytes)
OPERATION = self.CurrentOperand & 0x00FF
# Getting Key Register from CurrentOperand (get second byte)
KEY_REGISTER = (self.CurrentOperand & 0x0F00) >> 8
KEY_TO_CHECK = self.GeneralRegisters[KEY_REGISTER]
# Get array of all pressed keys
ALL_PRESSED_KEYS = key.get_pressed()
# Skip if the key specified in the source register is pressed
if OPERATION == 0x9E:
if ALL_PRESSED_KEYS[int(KEY_MAPPINGS[KEY_TO_CHECK])] == 1:
self.CpuRegisters['PC'] += 2
# Skip if the key specified in the source register is not pressed
if OPERATION == 0xA1:
if ALL_PRESSED_KEYS[int(KEY_MAPPINGS[KEY_TO_CHECK])] == 0:
self.CpuRegisters['PC'] += 2
def tick(self):
for event in Event.get():
if event.type == pygame.QUIT: raise QuitMessage('close button')
self._pressed = Key.get_pressed()
if self._inputs.has_key('quit'):
if self.isPressed('quit'):
raise QuitMessage('a quit chord was pressed')
def respond(self):
key_pressed = key.get_pressed()
if not self.pressed and key_pressed[K_SPACE]:
self.pressed = True
self.actor.activate()
if self.pressed and not key_pressed[K_SPACE]:
self.pressed = False
def movement(obj, up, down, left, right, extra):
global resultant_Force
keys = key.get_pressed()
obj.Acc.x = 0
obj.Acc.y = 0
if keys[left]:
obj.F_move.x = -Fm.x
if keys[right]:
obj.F_move.x = Fm.x
if keys[up]:
obj.F_move.y = Fm.y
if keys[down]:
obj.F_move.y = -Fm.y
if keys[extra]:
obj.Vel.y = 4500 * 0
obj.Vel.x = 3000 * 0
resultant_Force = obj.Fg + obj.F_move + obj.F_g + F_drag + obj.F_external # getting the resultant force
obj.Acc = resultant_Force * (1 / obj.mass
) # getting acceleration from force
obj.Vel += obj.Acc * dt # getting velocity from acceleration
obj.Pos += obj.Vel * dt # getting position from velocity
obj.F_move.x = 0
obj.F_move.y = 0
def _calc_movement(self, screen, newRoom):
x = 0
y = 0
buttons = mouse.get_pressed()
keys = key.get_pressed()
if keys[pygame.K_LEFT] or keys[pygame.K_a]:
x = -self._data.vel
if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
x = self._data.vel
if keys[pygame.K_UP] or keys[pygame.K_w]:
y = -self._data.vel
if keys[pygame.K_DOWN] or keys[pygame.K_s]:
y = self._data.vel
if keys[pygame.K_SPACE] or buttons[0] == 1 and not newRoom:
self._weapon.fire(self._angle, self._data.attack_speed, self.rect)
if x != 0 and y != 0:
x *= 0.7071
y *= 0.7071
self._data.pos = self._data.pos + Vector2(x, y)
# must be called in this order, considering fixing later
self._calc_rotation()
self._check_walls(screen)
def checkInput(p):
"""
De checkInput functie controleert de gameinput. Als er een joystick is wordt de input daarvan
gebruikt. Is er geen joystick, dan gebruikt deze functie de LEFT-, RIGHT-, UP- en DOWN-toetsen
voor de besturing van de Player.
Invoer: 'p' = Het object player uit het spel (de Actor)
"""
global joyin, joystick_count
#Test1.7 global counter
# Handel de toetsen of voor het bewegen van de speler
p.movex = p.movey = p.angle = 0
x_axis = y_axis = 0
if joystick_count != 0:
x_axis = joyin.get_axis(0)
y_axis = joyin.get_axis(1)
if key.get_pressed()[K_LEFT] or x_axis < -0.8:
p.angle = 180
p.movex = -20
elif key.get_pressed()[K_RIGHT] or x_axis > 0.8:
p.angle = 0
p.movex = 20
elif key.get_pressed()[K_UP] or y_axis < -0.8:
p.angle = 90
p.movey = -20
elif key.get_pressed()[K_DOWN] or y_axis > 0.8:
p.angle = 270
p.movey = 20
#Test1.7 counter += 1
# if counter % 100 == 0:
# print(counter, x_axis, y_axis, p.angle, p.movex, p.movey)
# Handel de RETURN af voor het starten van het volgende leven van de speler
restartButton = False
if joystick_count != 0:
restartButton = joyin.get_button(1)
# Vastgesteld in stap 2.9 - Waarden van de buttons op de gamepad:
# Button X = 0
# Button A = 1
# Button B = 2
# Button Y = 3
# Button L = 4
# Button R = 5
# Button SELECT = 8
# Button START = 9
#Test2.7 print(p.status, key.get_pressed()[K_RETURN], restartButton, (p.status == 1 and (key.get_pressed()[K_RETURN] or restartButton))
return (p.status == 1 and (key.get_pressed()[K_RETURN] or restartButton))
def update(self, millis):
keys = key.get_pressed()
self.reverseGravity = keys[pygame.K_LSHIFT] or keys[pygame.K_SPACE]
self.text.update(millis)
for sprite in self.sprites:
sprite.update(millis)
def __get_pressed_key(self):
teclas_presionadas = []
pressed_keys = key.get_pressed()
for key_constant, pressed in enumerate(pressed_keys):
if pressed:
if self.__teclas_permitidas.count(key_constant) == 1:
teclas_presionadas.append(key_constant)
return teclas_presionadas
def checkInput(player):
if key.get_pressed()[K_LEFT]:
moveLeft(player)
elif key.get_pressed()[K_RIGHT]:
moveRight(player)
elif key.get_pressed()[K_UP]:
moveUp(player)
elif key.get_pressed()[K_DOWN]:
moveDown(player)
elif key.get_pressed()[K_SPACE]:
return 1
return 0
def get_command():
key_states = enumerate(key.get_pressed())
pressed_keys = set([x for (x,y) in key_states if y != 0])
known_pressed_keys = pressed_keys.intersection(known_keys)
if len(known_pressed_keys) > 0:
selected_key = sorted(list(known_pressed_keys))[0]
return command_dict[selected_key]
else:
return None
def handle(self, e):
if e.type == KEYDOWN:
pressed = key.get_pressed()
shifted = pressed[K_LSHIFT] or pressed[K_RSHIFT]
scroll = 10 if shifted else 1
if e.key == K_UP:
self._scroll(1, -scroll)
return True
elif e.key == K_DOWN:
self._scroll(1, scroll)
return True
elif e.key == K_LEFT:
self._scroll(0, -scroll)
return True
elif e.key == K_RIGHT:
self._scroll(0, scroll)
return True
elif e.unicode == '>':
self._zscroll(-1)
return True
elif e.unicode == '<':
self._zscroll(1)
return True
elif e.key == K_TAB:
self._select(self.cursor)
mouse.set_visible(False)
return True
elif (e.type == MOUSEBUTTONDOWN and
self.background and
self.background.get_rect().collidepoint(e.pos) and
e.button == 1):
self._select(self._absolutetile(mouse.get_pos()))
return True
elif (e.type == MOUSEBUTTONUP and
self.background and
self.background.get_rect().collidepoint(e.pos) and
e.button == 1):
self._dragging = False
return True
elif (e.type == MOUSEMOTION and self.background and
self.background.get_rect().collidepoint(e.pos) and
1 in e.buttons):
self._expandselection(self._absolutetile(mouse.get_pos()))
self._dragging = True
return False
def check_input(player):
xaxis = yaxis = 0
if joyin:
xaxis = joyin.get_axis(0)
yaxis = joyin.get_axis(1)
if key.get_pressed()[K_LEFT] or xaxis < -0.8:
player.angle = 180
player.movex = -20
if key.get_pressed()[K_RIGHT] or xaxis > 0.8:
player.angle = 0
player.movex = 20
if key.get_pressed()[K_UP] or yaxis < -0.8:
player.angle = 90
player.movey = -20
if key.get_pressed()[K_DOWN] or yaxis > 0.8:
player.angle = 270
player.movey = 20
def update(self, time):
keys = key.get_pressed()
if keys[pygame.K_UP]:
self.character.set_state("jumping")
elif keys[pygame.K_LEFT]:
self.character.left(time)
elif keys[pygame.K_RIGHT]:
self.character.right(time)
else:
self.character.set_state("standing")
def init_game(self):
move = key.get_pressed()
if move[self.buttons[0]] and self.point.top == 370:
self.point.top += 60
self.multiplayer = True
elif move[self.buttons[1]] and self.point.top == 430:
self.point.top -= 60
self.multiplayer = False
if move[self.buttons[2]]:
self.start = True
self.world = WorldWrapper(MAPS[self.level], self.multiplayer)
self.screen.blit(self.background, (self.back.x, self.back.y))
self.screen.blit(self.pointer, (self.point.x, self.point.y))
def update(self, time):
keys = key.get_pressed()
if keys[pygame.K_UP]:
self.character.set_state("jumping")
elif keys[pygame.K_LEFT]:
self.character.dir = characters.DIR_LEFT
self.character.set_state("running")
elif keys[pygame.K_RIGHT]:
self.character.dir = characters.DIR_RIGHT
self.character.set_state("running")
elif keys[pygame.K_SPACE]:
self.character.set_state("shooting")
def keyboard():
"""Checks for relevent keypresses and either
moves the player, shoots, or quits the game"""
key_states = key.get_pressed()
if key_states[K_ESCAPE]:
sys.exit()
if key_states[K_LEFT]:
player.move(WEST)
elif key_states[K_RIGHT]:
player.move(EAST)
if key_states[K_z] or key_states[K_SPACE] or key_states[K_LCTRL]:
shoot()
def handle_events(self):
keys = key.get_pressed()
if keys[K_q] or keys[K_ESCAPE]:
self.quit = True
if keys[K_SPACE] and self.stop:
self.reset()
self.stop = False
for evt in event.get():
if evt.type == QUIT:
self.quit = True
if evt.type == MOUSEBUTTONDOWN:
for ball in self.balls:
ball.reverse()
def handle_events(self):
keys = key.get_pressed()
if keys[K_q] or keys[K_ESCAPE]:
self.quit = True
for evt in event.get():
if evt.type == QUIT:
self.quit = True
if evt.type == MOUSEBUTTONUP:
self.planets[self.n]=PLANET(Vector2(mouse.get_pos()))
self.cm_velocity_zero()
self.n += 1
if evt.type == KEYDOWN:
self.quit = True
def _update(self):
"""not finished, please leave - Jonathan"""
event.pump()
keys = key.get_pressed()
if keys[K_LEFT]:
self.left()
elif keys[K_RIGHT]:
self.right()
if keys[K_SPACE]:
self.jump()
if self.walk_force:
self.do_walk()
def restart_game(self):
move = key.get_pressed()
if move[self.buttons[0]] and self.point.top == 480:
self.point.top += 60
self.restart = False
elif move[self.buttons[1]] and self.point.top == 540:
self.point.top -= 60
self.restart = True
elif move[self.buttons[3]]:
self.quit = True
if self.restart:
Game().game_loop(30)
self.screen.blit(self.over_screen, (self.over.x, self.over.y))
self.screen.blit(self.pointer, (self.point.x, self.point.y))
def move(self):
keys = key.get_pressed()
for k in [K_SPACE,K_UP]:
if keys[k]:
self.pic = self.pic_up
self.sound.play()
self.velocity.y = min(0,self.velocity.y-.1)
self.position.y += self.velocity.y
break
else:
self.sound.stop()
self.pic = self.pic_down
self.velocity.y = max(-3,self.velocity.y+.1)
self.position.y += self.velocity.y
if randint(1,1)==1:
self.tail = self.tail[1:]
self.tail.append(self.position.y)
def updateControls(self):
bools = key.get_pressed()
self.up = bools[pygame.K_UP] or bools[pygame.K_w]
self.down = bools[pygame.K_DOWN] or bools[pygame.K_s]
self.left = bools[pygame.K_LEFT] or bools[pygame.K_a]
self.right = bools[pygame.K_RIGHT] or bools[pygame.K_d]
self.w = bools[pygame.K_w]
self.s = bools[pygame.K_s]
self.a = bools[pygame.K_a]
self.d = bools[pygame.K_d]
self.f = bools[pygame.K_f]
self.p[0] = bools[pygame.K_p]
m = mouse.get_pressed()
self.mClicked = m[0]
self.mloc = mouse.get_pos()
self.space = bools[pygame.K_SPACE] or bools[pygame.K_RETURN]
self.one[0] = bools[pygame.K_1]
def game(puzzleNumber, gameWindow, solvedPuzzles):
backGroundColor = (255, 255, 255)
running = 1
puzzle = LoadPuzzle(puzzleNumber)
load = LoadData()
save = SaveData()
baseSquare = load.load("square.png", "img", 1)
crossSquare = load.load("empty_sq.png", "img", 1)
clueImages = (load.load("clue_top.png", "img", 1),
load.load("clue_right.png", "img", 1))
gameWindow.fill(backGroundColor)
baseGameArea = Make_sqrect(puzzle.puzzleSize) #TODO: Needs to be at the
CollisionSquares = Make_sqrect(puzzle.puzzleSize, 1) # center of the window
blit = gameWindow.blit
for square in baseGameArea:
blit(baseSquare, square)
DrawClues(puzzle.puzzleSize, gameWindow, clueImages, puzzle.leftClues,
puzzle.topClues, puzzle.puzzleTitle)
filledSquares = []
display.update()
while running:
for ev in event.get():
if ev.type == QUIT: quitprogram()
elif ev.type == MOUSEBUTTONDOWN:
if ev.button == 1:
filledSquares = MouseClicks(CollisionSquares, gameWindow, 1,
filledSquares, backGroundColor)
elif ev.button == 2:
filledSquares = MouseClicks(CollisionSquares, gameWindow, 2,
filledSquares, backGroundColor)
elif ev.button == 3:
filledSquares = MouseClicks(CollisionSquares, gameWindow, 3,
filledSquares, backGroundColor, crossSquare)
running = PuzzleChecker(filledSquares, puzzle.winSquares,
puzzleNumber, gameWindow, backGroundColor)
display.update()
elif ev.type == KEYDOWN:
keys = key.get_pressed()
if keys[K_ESCAPE]:
return solvedPuzzles
save.saveSolvedPuzzles(solvedPuzzles, puzzleNumber)
wait(1.5)
return solvedPuzzles
def update(self, millis):
super(Player, self).update(millis)
# get input
keys = key.get_pressed()
# move based in key input
if keys[pygame.K_LEFT]:
self.applyForce([ -self.acceleration * millis / 1000, 0 ])
if keys[pygame.K_RIGHT]:
self.applyForce([ self.acceleration * millis / 1000, 0 ])
if keys[pygame.K_UP]:
self.applyForce([ 0, -self.acceleration * millis / 1000 ])
if keys[pygame.K_DOWN]:
self.applyForce([ 0, self.acceleration * millis / 1000 ])
# rotate score chain
self.baseChainAngle = (self.baseChainAngle + pi * millis / 8000) % (pi * 2)
def main(self):
clock = time.Clock()
while 1:
dt = clock.tick(30)
for _event in event.get():
if _event.type == QUIT:
return
if _event.type == KEYDOWN and _event.key == K_ESCAPE:
return
self.tilemap.update(dt / 1000., self.tilemap, key.get_pressed(), self.player)
self.screen.blit(self.background, (0, 0))
self.tilemap.draw(self.screen)
display.flip()
if self.player.is_dead:
print('YOU DIED')
return
def update(self, delta, world, walls):
if not self.player.dead:
choice = key.get_pressed()
if self.player.turn == 1:
control = (K_UP, K_DOWN, K_LEFT, K_RIGHT, K_SPACE)
sign = 'Y'
else:
control = (K_w, K_s, K_a, K_d, K_TAB)
sign = 'G'
direction = Vec2D(0, 0)
if choice[control[0]]:
direction = Vec2D(0, -1)
self.player.angle = 0
if choice[control[1]]:
direction = Vec2D(0, 1)
self.player.angle = -180
if choice[control[2]]:
direction = Vec2D(-1, 0)
self.player.angle = 90
if choice[control[3]]:
direction = Vec2D(1, 0)
self.player.angle = -90
direction = direction * TILE_SIZE * delta
if world.enemy_hit_tile(self.player.coords + direction):
return
direction = world.validify_direction(self.player.coords, direction)
# if world.valid_direction(direction, world):
self.player.move(direction, world.world)
if not direction.zero():
world.update_aim_lines()
if self.reload_time > 0:
self.reload_time -= delta
if choice[control[4]]:
self.shoot()
def register_key_down(self, key, fn, *args, **kwargs):
"""register_key_down(key, fn, *args, **kwargs)
Register a function to execute when a given key is pressed. If the key is being
pressed when this is registered, the function will be executed immediately
unless the kwarg _do_immediate is set to False.
key: can be either a keys[] constant (or index) from pig.keyboard or a tuple in
the form (keymods[] constant/index, keys[] constant/index)
fn: the function to call when the keypress occurs
*args, **kwargs: arguments to fn
"""
# if key is already down, perform function
if kwargs.pop('_do_immediate', True):
try:
if type(key) is tuple:
if type(key[0]) is str:
keymod = keymods[key[0]]
else:
keymod = key[0]
if type(key[1]) is str:
thekey = keys[key[1]]
else:
thekey = key[1]
if type(key) is str:
thekey = keys[key]
keymod = 0
pressed = get_pressed()[thekey]
if pressed:
mods = get_mods() & ~4096
if keymod is 0:
if mods:
pressed = False
else:
if not (keymod & mods):
pressed = False
except:
pass
else:
if pressed:
fn(*args,**kwargs)
return self._register_key( self._key_down_dict, key, fn,
*args, **kwargs)
