def _collisions_detec(self): if self.player and (pygame.sprite.spritecollideany( self.player, self.bullets_group) or pygame.sprite.spritecollideany( self.player, self.enemies_group)): event = Event( pygame.USEREVENT, dict(value=CreateElementEvent( element=_create_animation(self.player)))) pygame.event.post(event) self.player.kill() self.player = None self.life_panel.update_life(-1) if self.life_panel.lives_count <= 0: self._create_element(Text('GAME OVER')) else: event = Event( pygame.USEREVENT, dict(value=CreateDelayedEvent( delay=700, element=self, event=RestartPlayerEvent()))) pygame.event.post(event) items = pygame.sprite.groupcollide(self.enemies_group, self.bullets_group, True, True) for enemy in items.keys(): event = Event( pygame.USEREVENT, dict(value=CreateElementEvent( element=_create_animation(enemy)))) pygame.event.post(event) self.score_panel.update_score(100)
def setup(self, world): context = world.find_component("context") background = context["background"] player_entity = world.find_entity("player") # Create a sprite for the header self.pause = pygame.sprite.Sprite() self.pause.image = self.huge_font.render("You Crashed!", 1, (200, 200, 200)) self.pause.rect = self.pause.image.get_rect( centerx=background.get_width() // 2, centery=background.get_height() // 4) self.pause_help = pygame.sprite.Sprite() self.pause_help.image = self.regular_font.render( "Try hitting clouds, birds, or airplanes to get money for upgrades!", 1, (200, 200, 200), ) self.pause_help.rect = self.pause_help.image.get_rect( centerx=background.get_width() // 2, centery=background.get_height() // 2) self.pause_currency = pygame.sprite.Sprite() self.pause_currency.image = self.regular_font.render( f"Current money for upgrades: ${ player_entity.player.currency }", 1, (200, 200, 200), ) self.pause_currency.rect = self.pause_currency.image.get_rect( centerx=background.get_width() // 2, centery=background.get_height() // 2 + 100, ) # menu setup men = [ ("Quit", lambda: post(Event(PAUSE_QUIT_TO_MENU))), ("Save + Continue", lambda: post(Event(PAUSE_SAVE_AND_QUIT))), ] for idx, m in enumerate(men): offset = -((len(men) * 480) // 2) + 240 rect = pygame.Rect(0, 0, 190, 49) rect.centerx = background.get_width() // 2 + (offset + (idx * 480)) rect.centery = background.get_height() - 100 button = world.gen_entity() button.attach(ButtonComponent( rect, m[0].upper(), m[1], )) # Put all the sprites we want to render into a sprite group for easy adds and removes self.pause_screen = pygame.sprite.Group() self.pause_screen.add(self.pause) self.pause_screen.add(self.pause_help) self.pause_screen.add(self.pause_currency)
def _collision_detection(self): if not self.player.hidden: # husband sight range simulated by rectangle with given size width = 100 height = 70 block = Block(width, height) # compute sight rectangle coordinates in order to detect whether player has been seen or not if self._direction == "R": block.rect.x = self.rect.x + width block.rect.y = self.rect.y elif self._direction == "L": block.rect.x = self.rect.x - width block.rect.y = self.rect.y # check if player is in the husband sight if pygame.sprite.collide_rect(block, self.player): #print "I see you!!!" Husband._increase_suspicion_meter(10) if Husband._suspicion_value < 100: pygame.event.post(Event(pygame.USEREVENT, {"action": constants.MESSAGE, "message": "I see you!!!", "time": 5})) # check if husband caught player if pygame.sprite.collide_rect(self, self.player): #print "I got you!!!" Husband._increase_suspicion_meter(100) pygame.event.post(Event(pygame.USEREVENT, {"action": constants.MESSAGE, "message": "GAME OVER", "time": 10, "kill": True}))
def setup(self, world): context = world.find_component("context") background = context["background"] # Create a sprite for the header self.pause = pygame.sprite.Sprite() self.pause.image = self.regular_font.render("Paused", 1, (200, 200, 200)) self.pause.rect = self.pause.image.get_rect( centerx=background.get_width() // 2, centery=background.get_height() // 4) options = [ ("Continue", lambda: post(Event(PAUSE_CONTINUE))), ("Save & Quit", lambda: post(Event(PAUSE_SAVE_AND_QUIT))), ("Quit to Menu", lambda: post(Event(PAUSE_QUIT_TO_MENU))), ] for idx, menu_item in enumerate(options): offset = 0 rect = pygame.Rect(0, 0, 200, 60) rect.centerx = background.get_width() // 2 rect.centery = background.get_height() // 2 + (offset + (idx * 70)) button = world.gen_entity() button.attach( ButtonComponent( rect, menu_item[0].upper(), menu_item[1], )) # Put all the sprites we want to render into a sprite group for easy adds and removes self.pause_screen = pygame.sprite.Group() self.pause_screen.add(self.pause)
def test_invoke_handler_accepting_input(self): controller = InputController() test_object = TestObject() controller.register_handler(InputAction.PRESS, Key.CONFIRM, test_object.test_function) self.assertTrue(len(controller.__subscribers__[(InputAction.PRESS, Key.CONFIRM)]) > 0) # Try to invoke the handler test_event = Event(KEYDOWN, { 'key': K_RETURN }) controller.invoke_handlers(test_event) self.assertTrue(test_object.test_function_has_been_called) # Disable accepting input and try to invoke the handler test_object.test_function_has_been_called = False test_object.accepting_input = False # Try to invoke the handler again test_event = Event(KEYDOWN, { 'key': K_RETURN }) controller.invoke_handlers(test_event) self.assertFalse(test_object.test_function_has_been_called)
def setup(self, world): context = world.find_component("context") settings = world.find_component("settings") background = context["background"] # Create our player entity here, and we can extend it once we pick an option # player_entity = world.gen_entity() # player_entity.attach(PlayerComponent()) # menu setup men = [] men.append(("New Game", lambda: post(Event(NEW_GAME)))) if path.exists( path.join(user_data_dir(APP_NAME, APP_AUTHOR), settings["save_file"])): men.append(("Continue", lambda: post(Event(CONTINUE)))) men.append(("How to Play", lambda: post(Event(CONTROLS)))) men.append(("Credits", lambda: post(Event(CREDITS)))) men.append(("Quit", lambda: post(Event(QUIT)))) for idx, m in enumerate(men): offset = -((len(men) * 60) // 2) + 140 rect = pygame.Rect(0, 0, 200, 60) rect.centerx = background.get_width() // 2 rect.centery = background.get_height() // 2 + (offset + (idx * 60)) button = world.gen_entity() button.attach(ButtonComponent( rect, m[0].upper(), m[1], ))
def test_keyboard_keyup_event(): env = DummyPlayEnv() game = PlayableGame(env, dummy_keys_to_action()) event = Event(pygame.KEYDOWN, {"key": RELEVANT_KEY_1}) game.process_event(event) event = Event(pygame.KEYUP, {"key": RELEVANT_KEY_1}) game.process_event(event) assert game.pressed_keys == []
def _augmentEvent(self, theEvent: Event, theIndex: int) -> Event: if theEvent is None: theEvent = Event(USEREVENT, {'index': theIndex}) else: theEvent.dict['index'] = theIndex return theEvent
def envoie_evenement(quoi, nom_parametre=None, valeur_parametre=None): if nom_parametre is None or valeur_parametre is None: pygame.event.post(Event(USEREVENT, {'quoi': quoi})) else: pygame.event.post( Event(USEREVENT, { 'quoi': quoi, nom_parametre: valeur_parametre }))
def test_arrow_press_release(self, press=True): arrow_event = pygame.KEYDOWN if press else pygame.KEYUP pygame.event.post(Event(arrow_event, key=pygame.K_RIGHT)) pygame.event.post(Event(arrow_event, key=pygame.K_LEFT)) gf.check_events(self.ai_settings, self.stats, self.screen, self.play_button, self.ship, self.aliens, self.bullets) actual = [self.ship.moving_right, self.ship.moving_left] expected = [press] * 2 self.assertEqual(expected, actual) if press: self.test_arrow_press_release(press=False)
def test_play_button_click(self): """Test if game is activated and reset when the play button is clicked""" pygame.event.post(Event(pygame.KEYDOWN, key=pygame.K_SPACE)) screen_rect = self.screen.get_rect() pygame.event.post(Event(pygame.MOUSEBUTTONDOWN)) gf.check_events(self.ai_settings, self.screen, self.stats, self.play_button, self.ship, self.aliens, self.bullets) full_fleet = Group() gf.create_fleet(self.ai_settings, self.screen, self.ship, full_fleet) actual = self.stats.game_active and (len( self.aliens) == len(full_fleet) and len(self.bullets) == 0) self.assertEqual(True, actual)
def move_leftover_pieces(self, leftovers): for piece in leftovers: movement_range = piece.attr(Attribute.MOVEMENT_RANGE) movement_type = piece.attr(Attribute.MOVEMENT_TYPE) if movement_range > 0: if (piece.gx, piece.gy) in self.planned_occupied_coords: valid_tiles = self.map.get_tiles_in_range( piece.gx, piece.gy, 0, movement_range, movement_type) # Remove planned coords from valid tiles valid_tiles = list( set(valid_tiles) - set(self.planned_occupied_coords)) # Pick an arbitrary tile and pathfind to it # destination = valid_tiles[randint(0, len(valid_tiles) - 1)] if len(valid_tiles) == 0: # No possible valid destination! Just destroy ourselves piece.set_order( Event(USEREVENT, { 'option': Option.MENU_DEMOLISH_SELF, })) else: destination = valid_tiles[0] path = piece.get_path_to_target( destination, self.path_cache, self.planned_occupied_coords, movement_type=movement_type) final_goal = piece.step_along_path( path, self.planned_occupied_coords) if final_goal == (piece.gx, piece.gy): # We couldn't find a path to get out of the way, so delete ourselves piece.set_order( Event(USEREVENT, { 'option': Option.MENU_DEMOLISH_SELF, })) else: # Update the planned occupied coords, issue the order self.planned_occupied_coords.append(final_goal) piece.set_order( Event( USEREVENT, { 'option': Option.MENU_MOVE, 'dx': final_goal[0], 'dy': final_goal[1], })) else: # Add ourselves to the planned occupied coords self.planned_occupied_coords.append((piece.gx, piece.gy))
def update(self, *_): super(Bomber, self).update() if self.counter % 75 == 0: (x, y) = self.get_position() s_1 = self.__create_shot() s_1.set_position((x - self.get_width() / 3, y)) s_2 = self.__create_shot() s_2.set_position((x + self.get_width() / 3, y)) e_1 = Event(ENEMY_FIRE, ship=self, shot=s_1) e_2 = Event(ENEMY_FIRE, ship=self, shot=s_2) post(e_1) post(e_2)
def __init__(self, app, name: str): super().__init__(app, name) self.custom_level = CustomLevel() self.images = {'free_cell': Surface((128, 128), SRCALPHA), 'wall': Surface((128, 128), SRCALPHA), 'box_cell': Surface((128, 128), SRCALPHA), 'player': Surface((128, 128), SRCALPHA), 'box': Surface((128, 128), SRCALPHA)} self.images['free_cell'].blit(FREE_CELL_IMAGE, (0, 0)) self.images['wall'].blit(WALL_IMAGE, (0, 0)) self.images['box_cell'].blit(BOX_CELL_IMAGE, (0, 0)) self.images['player'].blit(PLAYER_IMAGE, (0, 0)) self.images['box'].blit(BOX_IMAGE, (0, 0)) self.dragged_picture = None self.still_pictures = [StillPicture(' '), StillPicture('b'), StillPicture('p'), StillPicture('x')] self.level_name_box = TextBox( self.application.screen, (self.application.screen.get_width() / 2 - TEXTBOX_SIZE[0] / 2, 10)) self.level_name_box.str = _('my level') self.cell_size = None self.offset_x, self.offset_y = None, None self.symbols_to_images = {} self.calculate_cell_size() self.buttons = [ Button( _('MENU'), self.application.screen, Event(pygame.USEREVENT, {'app': self.application, 'name': '__main__'}), (0, 0)), Button( _('SAVE'), self.application.screen, Event(pygame.USEREVENT, {'app': self.application, 'name': 'save'}), (self.application.screen.get_width() - BUTTON_SIZE[0], 0)), Button( 'OK', self.application.screen, Event(pygame.USEREVENT, {'app': self.application, 'name': 'ok'}), (self.level_name_box.rect_box.right + 10, self.level_name_box.rect.top), button_size=(40, 30)) ]
def handle_menu_click(self, menu_item): if menu_item.item_id == ITEM_NEW_GAME: self._cur_menu = MENU_DIFFICULTY elif menu_item.item_id == ITEM_LEVEL_SELECT: self._cur_menu = MENU_LEVEL_SELECT elif (menu_item.item_id == ITEM_EASY or menu_item.item_id == ITEM_HARD or menu_item.item_id == ITEM_MEDIUM): pygame.event.post(Event(START_LEVEL1_EVENT, dict())) elif menu_item.item_id == ITEM_LEVEL_1: pygame.event.post(Event(START_LEVEL1_EVENT, dict())) elif menu_item.item_id == ITEM_LEVEL_2: pygame.event.post(Event(START_LEVEL2_EVENT, dict())) elif menu_item.item_id == ITEM_BONUS_LEVEL: pygame.event.post(Event(START_BONUS_LEVEL_EVENT, dict()))
def _drag_move(self, event): ev_drag = Event(constants.THORPY_EVENT, id=constants.EVENT_DRAG, el=self) post(ev_drag) self.move((self._constraints[0] * event.rel[0], self._constraints[1] * event.rel[1]))
def test_keyboard_quit_event(): env = DummyPlayEnv() game = PlayableGame(env, dummy_keys_to_action()) event = Event(pygame.KEYDOWN, {"key": pygame.K_ESCAPE}) assert game.running is True game.process_event(event) assert game.running is False
def handle(): global running, moving for e in pygame.event.get(): if e.type == QUIT: running = False elif e.type == KEYDOWN: if e.key in MOVES.keys(): moving = (moving[0] + MOVES[e.key][0], moving[1] + MOVES[e.key][1]) elif e.type == KEYUP: if e.key in MOVES.keys(): moving = (moving[0] - MOVES[e.key][0], moving[1] - MOVES[e.key][1]) elif e.type == MOUSEBUTTONDOWN: pos = slide_x + e.pos[0]/TILE, slide_y + e.pos[1]/TILE send(Event(GETINFO, {'pos':pos})) elif e.type == GOTO: goto(e.x, e.y) elif e.type == MESSAGE: settext(e.msg) elif e.type == SYSTEM: print e.msg elif e.type == SETOBJECT: objmap[e.y][e.x] = e.obj elif e.type == TWITTER: print "\nAmigos Online:" print e.msg
def update(self, events, world): settings = world.find_component("settings") for event in events: if event.type == EQUIP_QUIT: return SceneManager.new_root(scenes.title.TitleScene()) if event.type == EQUIP_BUY_CLOUD_SLEEVES: self._shop(settings["cloudSleevesCost"], "cloud_sleeves", world) self.teardown(world) self.setup(world) if event.type == EQUIP_BUY_WINGS: self._shop(settings["wingsCost"], "wings", world) self.teardown(world) self.setup(world) if event.type == EQUIP_BUY_JET_BOOTS: self._shop(settings["jetBootsCost"], "jet_boots", world) self.teardown(world) self.setup(world) if event.type == EQUIP_SAVE_AND_START: self._save(settings["save_file"], world) self.teardown(world) post(Event(LOAD)) return SceneManager.pop() world.process_all_systems(events)
def move((inc_x, inc_y)): if inc_x != 0 or inc_y != 0: e = Event(GOTO, { 'x': slide_x + inc_x + MIDDLE[0], 'y': slide_y + inc_y + MIDDLE[1] }) pygame.event.post(e)
def test_pygame_quit_event(): env = DummyPlayEnv() game = PlayableGame(env, dummy_keys_to_action()) event = Event(pygame.QUIT) assert game.running is True game.process_event(event) assert game.running is False
def poll(): """Get the next pending event if exists. Otherwise, return pygame.NOEVENT.""" pump() try: return g_events.get(block=False) except Queue.Empty: return Event(pygame.NOEVENT)
def POST_SPECIAL_FLAG_CHANGE(text): GUI_SCREEN_SPECIAL_FLAGS_CHANGED: Union[Event, None] = Event( pygame.USEREVENT, { 'user_type': 'screen_flag_changed', 'text': text }) pygame.event.post(GUI_SCREEN_SPECIAL_FLAGS_CHANGED)
def event_handler(self, event): # When the menu is open, set the selected value and close the menu # When the menu is closed, open the menu for sprite in self.sprites(): if sprite.rect.collidepoint(mouse.get_pos()) \ and event.type == MOUSEBUTTONDOWN: if self.menu_open: if not sprite.value: raise Exception( "Invalid option clicked, Selector class does not have the property option" ) self.value = sprite.value PyEvent.post( Event( UIManager.BUTTON_EVENT_ID, { 'component_id': self.component_id, 'event': UIDropdownMenu.ON_VALUE_CHANGED, 'value': self.value })) self.close() return else: self.open() return # close the menu when outside the menu is clicked if event.type == MOUSEBUTTONDOWN and self.menu_open: self.close()
def update(self, *_): """ Overrides the update in Ship. For the player, as with the aliens, this mostly handles firing, but it also makes sure that the image displayed when blitting is the one currently active from the animation """ # Maybe change the animation image self.__animation.update() # And in that case, this changes, too! self.set_image(self.__animation.get_image()) self.mask = self.__hitmask super(Player, self).update() # Fires more when highpowered if self.__firing and not self.has_target(): if self.__firecounter % 10 == 0: self.__firecounter = 1 shots = min(2 + self.__power, 6) sound = True for i in range(shots): shot = self.__create_shot(sound) for _ in range(i): shot.update() post(Event(USER_FIRE, shot = shot)) sound = False else: self.__firecounter += 1 elif self.__firecounter != 0: # Prevents abuse of the fire button self.__firecounter = (self.__firecounter + 1) % 10
def test_space_press_responce(self): """Check if a bullet gets fired when space is pressed""" pygame.event.post(Event(pygame.KEYDOWN, key=pygame.K_SPACE)) gf.check_events(self.ai_settings, self.stats, self.screen, self.play_button, self.ship, self.aliens, self.bullets) actual = len(self.bullets) expected = 1 self.assertEqual(expected, actual)
def poll(): """Get the next pending event if exists. Otherwise, return pygame.NOEVENT.""" pump() try: result = g_events.get(block=False) return _recordEvents([result])[0] except Queue.Empty: return Event(pygame.NOEVENT)
def _press(self): state_ok = self.current_state == self._states[STATE_NORMAL] if state_ok: self.change_state(STATE_PRESSED) self._hover() ev_press = Event(THORPY_EVENT, id=EVENT_PRESS, el=self) post(ev_press) self._remove_help()
def build_event(event_type_id: int, **kwargs) -> Event: """ Pass-through function to build a PyGame event :param event_type_id: int :param kwargs: mixed, key-value data passed to the event :return: Event """ return Event(event_type_id, **kwargs)
def _random_move(self): event = Event( pygame.USEREVENT, dict(value=CreateDelayedEvent(delay=random.randint( *self.config.movement_freq), element=self, event=ChangeDirectionEvent()))) pygame.event.post(event)
def get_mouse_for(widget): last = last_mouse_event event = Event(0, last.dict) event.dict['local'] = widget.global_to_local(event.pos) add_modifiers(event) return event