def game_loop():
"""Internal game loop function that has access to clock, screen, etc."""
player = Player()
asteroid_cooldown = 0
while player:
for event in get_events():
if event.type == QUIT:
raise SystemExit('Thanks for playing!')
laser_collide = groupcollide(player.lasers, Asteroid.group, True, True, collide_circle)
player_collide = spritecollide(player, Asteroid.group, True, collide_circle)
if player_collide:
Asteroid.number_destroyed -= 1
player.kill()
player = None
if asteroid_cooldown <= 0:
# Spawn a new asteroid at a random point on the
# border of the screen, at a random angle and speed
x = 0
y = 0
side = randrange(1, 4)
if side == 1:
x = 0
y = randrange(0, SCREEN_HEIGHT)
if side == 2:
x = randrange(0, SCREEN_WIDTH)
y = 0
if side == 3:
x = SCREEN_WIDTH
y = randrange(0, SCREEN_HEIGHT)
if side == 4:
x = randrange(0, SCREEN_WIDTH)
y = SCREEN_HEIGHT
angle = randrange(0, 360)
speed = randrange(1, 5)
asteroid = Asteroid(3, speed, angle, pos=(x, y))
asteroid_cooldown = 450
# Draw the background to the screen
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))
# Update all entities and draw them
Entity.group.update()
Entity.group.draw(screen)
# Display what has been drawn
display.update()
asteroid_cooldown -= 1
# Advance the clock
clock.tick(FPS)
def handle_events():
closed = False
event_list = get_events()
for event in event_list:
if event.type == QUIT:
closed = True
return closed
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 handle_events(self):
# Handle the current game events. Return True if the player
# clicked the close icon and False otherwise.
event_list = get_events()
for event in event_list:
# handle one event
self.handle_one_event(event)
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 handle_events(game):
# handle the exit game event when the player clicks [X]
# - game is the Game whose events should be handled
event_list = get_events()
for event in event_list:
if event.type == QUIT:
game.close_selected = True
def handle_events(self):
event_list = get_events()
for event in event_list:
if event.type == QUIT:
self.close_selected = True
elif event.type == MOUSEBUTTONUP:
self.small_dot.generate_center()
self.big_dot.generate_center()
def handle_events(game):
# Handle the current game events. Return True if the player
# clicked the close icon and False otherwise.
event_list = get_events()
for event in event_list:
# handle one event
if event.type == QUIT:
game.close_selected = True
def handle_events(self):
# Handle the current game events by changing the game state
# appropriately.
# - self is the Game whose events will be handled
event_list = get_events()
for event in event_list:
self.handle_one_event(event)
def handle_events(game):
# Handle the current game events by changing the game state appropriately.
# - game is the Game whose events will be handled
event_list = get_events()
for event in event_list:
# handle one event
if event.type == QUIT:
game.close_selected = True
def handle_events():
# handle the exit game event when the player clicks [X]
closed = False
event_list = get_events()
for event in event_list:
if event.type == QUIT:
closed = True
return closed
def handle_events(self): event_list=get_events() for event in event_list: if event.type==QUIT: self.close_selected=True elif self.continue_game and event.type==MOUSEBUTTONUP: self.handle_mouse_click()
def handle_events(self) : closed = False event_list = get_events() for event in event_list : if QUIT == event.type : closed = True elif MOUSEBUTTONUP == event.type : self.handle_mouse_up( ) self.close_selected = closed
def _handle_events(self):
# handle the exit game event when the player clicks [X]
event_list = get_events()
for event in event_list:
if event.type == QUIT:
self._close_selected = True
elif event.type == MOUSEBUTTONUP and self._continue:
self._small_dot.randomize()
self._big_dot.randomize()
def handle_events(game):
event_list = get_events()
for event in event_list:
if event.type == QUIT:
game.close_selected = True
elif event.type == MOUSEBUTTONUP:
game.small_dot.center = generate_center(game,
game.small_dot.radius)
game.big_dot.center = generate_center(game, game.big_dot.radius)
def _handle_events(self):
# handle the exit game event when the player clicks [X]
# - game is the Game whose events should be handled
event_list = get_events()
for event in event_list:
if event.type == QUIT:
self._close_selected = True
elif event.type == MOUSEBUTTONUP:
self._small_dot.randomize()
self._big_dot.randomize()
def handle_events():
# Handle the current game events. Return True if the player clicked the
# close icon and False otherwise.
closed = False
event_list = get_events()
for event in event_list:
# handle one event
if event.type == QUIT:
closed = True
return closed
def handle_events(game):
# handle the exit game event when the player clicks [X]
# - game is the Game whose events should be handled
event_list = get_events()
for event in event_list:
if event.type == QUIT:
game.close_selected = True
elif event.type == MOUSEBUTTONUP:
randomize_dot(game.small_dot)
randomize_dot(game.big_dot)
def _handle_events(self):
events = get_events()
for event in events:
if event.type == MOUSEBUTTONUP:
self.randomize_dots()
if event.type == QUIT:
self._close = True
if event.type == KEYDOWN:
if event.key == K_q:
self._close = True
def handle_events(game):
# Handle the current game events by changing the game state appropriately.
# - game is the Game whose events will be handled
event_list = get_events()
for event in event_list:
# handle one event
if event.type == QUIT:
game.close_selected = True
elif event.type == MOUSEBUTTONUP:
randomize_dot(game.window, game.small_dot)
randomize_dot(game.window, game.big_dot)
def game_over(self):
self.draw_game_over()
pause = True
while pause:
for event in get_events():
if event.type == QUIT or (event.type == KEYDOWN
and event.key == K_q):
self._close = True
pause = False
if event.type == KEYDOWN and event.key == K_RETURN:
self.__init__()
pause = False
def _monitor(self):
"""Check for events."""
evts = []
try:
evts = get_events()
except pygame_error:
return False
for event in evts:
if event != None:
if event.type == CONFIGURATION["EVENT_TYPES"]["key_up"] or event.type == CONFIGURATION["EVENT_TYPES"]["key_down"]:
event.modifiers = get_keyboard_modifiers()
self.dispatch(event)
return True
def __call__(self):
self.running = True
while self.running:
for event in get_events():
for listener in self.event_listeners[event.type]:
d = event.dict
if 'pos' in event.dict:
d['pos'] = Vector2(d['pos'])
listener(**d)
self.loop()
update_display()
self.clock.tick()
def _clean_events(self, pressed_keys: Sequence[bool]) -> List[Event]:
result = []
for current_event in get_events():
quit_attempt = False
if current_event.type == QUIT:
quit_attempt = True
elif current_event.type == KEYDOWN:
alt_pressed = pressed_keys[K_LALT] or pressed_keys[K_RALT]
if current_event.key == K_F4 and alt_pressed:
quit_attempt = True
if quit_attempt:
self.active_scene.terminate()
else:
result.append(current_event)
return result
def __call__(self): while self.running: for e in get_events(): event: EventType = e if event.type == QUIT_EVENT: self.running = False else: self.dispatch(event.type, event.dict) self.surface.fill(settings.colour_scheme.background) [c.render() for c in self.components] [b.render() for b in self.buttons] [s.render() for s in self.sliders] update_display() self.clock.tick(60) pg_quit()
def update(self, gdt, gt, rt):
events = []
last_mousemotion = None
if self._blocking:
events = [wait_for_event()]
else:
events = get_events()
for event in events:
if event.type == MOUSEMOTION:
# Emit signature: (pos, rel, buttons, only_last)
if self._only_last_mousemotion:
last_mousemotion = event
else:
self.signals["mousemotion"].emit(event.pos, event.rel, event.buttons, self._only_last_mousemotion)
elif event.type == MOUSEBUTTONUP:
# Emit signature: (pos, button)
if not self._wheel_block or event.button not in [self._wheel_button_down, self._wheel_button_up]:
self.signals["mousebuttonup"].emit(event.pos, event.button)
# detect click event
ex, ey = event.pos
mx, my = self._mousedown_pos.get(event.button, (-1, -1)) # if up is first
if (
mx > -1 and abs(ex - mx) <= self._click_error and abs(ey - my) <= self._click_error
) or not self._wheel_block:
# detect double click
now = get_ticks()
if now - self._last_click_time.get(event.button, 0) < self._doubleclick_delay:
self.signals["doubleclick"].emit(event.pos, event.button)
else:
self.signals["click"].emit(self._mousedown_pos[event.button], event.button)
self._last_click_time[event.button] = now
elif event.type == MOUSEBUTTONDOWN:
# Emit signature: (pos, button)
button = event.button
if not self._wheel_block or button not in [self._wheel_button_down, self._wheel_button_up]:
self.signals["mousebuttondown"].emit(event.pos, event.button)
# position for click event, see mousebuttonup
self._mousedown_pos[event.button] = event.pos
if button == self._wheel_button_down:
self.signals["wheeldown"].emit(event.pos)
elif button == self._wheel_button_up:
self.signals["wheelup"].emit(event.pos)
elif event.type == KEYDOWN:
# Emit Signature: (unicode, key, mod)
self.signals["keydown"].emit(event.unicode, event.key, event.mod)
elif event.type == KEYUP:
# Emit Signature (key, mod)
self.signals["keyup"].emit(event.key, event.mod)
elif event.type == JOYAXISMOTION:
# Emit Signiture: (joy, axis, value)
self.signals["joyaxismotion"].emit(event.joy, event.axis, event.value)
elif event.type == JOYBALLMOTION:
# Emit Signature: (joy, ball, rel)
self.signals["joyballmotion"].emit(event.joy, event.ball, event.rel)
elif event.type == JOYHATMOTION:
# Emit Signature: (joy, hat, value)
self.signals["joyhatmotion"].emit(event.joy, event.hat, event.value)
elif event.type == JOYBUTTONUP:
# Emit Signature: (joy, button)
self.signals["joybuttonup"].emit(event.joy, event.button)
elif event.type == JOYBUTTONDOWN:
# Emit Signature: (joy, button)
self.signals["joybuttondown"].emit(event.joy, event.button)
elif event.type == VIDEORESIZE:
# Emit Signature: (size, w, h)
self.signals["videoresize"].emit(event.size, event.w, event.h)
elif event.type == VIDEOEXPOSE:
self.signals["videoexpose"].emit()
elif event.type == USEREVENT:
self.signals["userevent"].emit()
elif event.type == QUIT:
self.signals["quit"].emit()
elif event.type == ACTIVEEVENT:
# Emit Signature: (gain, state)
self.signals["activeevent"].emit(event.gain, event.state)
if last_mousemotion:
# Emit Signature: (pos, rel, only_last)
event = last_mousemotion
self.signals["mousemotion"].emit(event.pos, event.rel, event.buttons, self._only_last_mousemotion)
self._last_mousemotion = None
self.signals["render"].emit()
def main():
"""Main game loop and event handling"""
init()
clock = Clock()
screen = display.set_mode(State.windowsize, RESIZABLE)
display.set_caption('HACK_')
board = SplashScreen()
while True:
for event in get_events():
if event.type == QUIT:
raise SystemExit('Thanks for playing!')
elif event.type == VIDEORESIZE:
# Reset screen surface and set resize flag on board
size = (event.w, event.h)
screen = display.set_mode(size, RESIZABLE)
State.windowsize = size
board.resize = True
elif event.type == KEYDOWN:
if event.key == K_RETURN:
if type(board) == SplashScreen:
State.teleport = Level.START
elif type(board) == EndScreen:
return
continue
try:
x, y = State.player.gridpos
except AttributeError:
# Player won't exist in some situations, so don't fail here
continue
if event.key == K_UP:
y -= 1
if event.key == K_DOWN:
y += 1
if event.key == K_LEFT:
x -= 1
if event.key == K_RIGHT:
x += 1
board.place_player((x, y))
if State.teleport:
# Transport the player to a different level
board.kill()
State.level = State.teleport
if State.teleport == Level.START:
board = LevelStart()
elif State.teleport == Level.ONE:
board = LevelOne()
elif State.teleport == Level.TWO:
board = LevelTwo()
elif State.teleport == Level.THREE:
board = LevelThree()
elif State.teleport == Level.FOUR:
board = LevelFour()
elif State.teleport == Level.END:
board = EndScreen()
spawn_player(board)
State.teleport = None
# Update all entities and draw them
screen.blit(board.image, (0, 0))
board.update()
Entity.group.update()
Entity.group.draw(screen)
# Display what has been drawn
display.update()
# Advance the clock
clock.tick(FPS)
def events(self):
# function events() contains a loop to detect all kinds of user action
# and make reaction
event_list = get_events()
for event in event_list:
self.single_event(event)
def handle_events(self):
event_list = get_events()
for event in event_list:
self.handle_one_event(event)
def handle_events(game):
event_list = get_events()
for event in event_list:
if event.type == QUIT:
game.close_selected = True
