def run_pygame_collide(args): """Test if spritecollide works without pygame.init() called Rect(left, top, width, height) -> Rect """ logg = logging.getLogger(f"c.{__name__}.run_pygame_collide") logg.info(f"Start run_pygame_collide") c_rect = Rect(10, 20, 40, 80) logg.debug(f"c_rect {c_rect}") car = Sprite() car.rect = c_rect logg.debug(f"car {car}") segments = [] for i in range(5): new_seg = Sprite() s_rect = Rect(i * 30, i * 50, 40, 80) new_seg.rect = s_rect segments.append(new_seg) mmap = Group() for seg in segments: mmap.add(seg) logg.debug(f"mmap {mmap}") hits = spritecollide(car, mmap, dokill=False) for segment in hits: # logg.debug(f"hit segment with id {segment.s_id}") # logg.debug(f"hit segment {segment}") logg.debug(f"hit segment with rect {segment.rect}")
def start_resultmode(result, money): global all_sprites, resultmode_fon, resultmode_money_group, resultmode_score_group, resultmode_total_group global resultmode_menu_button, resultmode_return_button, resultmode_bonus, finish pygame.mixer.music.stop() finish.play() all_sprites = Group() resultmode_fon = Sprite() resultmode_fon.image = pygame.image.load( 'data/Images/game_over_stuff/gameover.png') resultmode_fon.rect = resultmode_fon.image.get_rect() resultmode_fon.rect.x = 182 resultmode_fon.rect.y = 50 all_sprites.add(resultmode_fon) resultmode_menu_button = Sprite() resultmode_menu_button.image = pygame.image.load( 'data/Images/game_over_stuff/menu button.png') resultmode_menu_button.rect = resultmode_menu_button.image.get_rect() resultmode_menu_button.rect.x = 182 + 45 resultmode_menu_button.rect.y = 470 all_sprites.add(resultmode_menu_button) resultmode_return_button = Sprite() resultmode_return_button.image = pygame.image.load( 'data/Images/game_over_stuff/return button.png') resultmode_return_button.rect = resultmode_return_button.image.get_rect() resultmode_return_button.rect.x = 400 resultmode_return_button.rect.y = 470 all_sprites.add(resultmode_return_button) all_sprites.draw(main_screen) resultmode_score_group = Group() transform_number(result, resultmode_score_group, (175 + 182, 205)) resultmode_score_group.draw(main_screen) resultmode_money_group = Group() x = transform_number( str(money) + '+', resultmode_money_group, (150 + 182, 290)) resultmode_money_group.draw(main_screen) bonus = int(result * 0.02) resultmode_bonus = Group() transform_number(bonus, resultmode_bonus, (x, 290)) resultmode_bonus.draw(main_screen) resultmode_total_group = Group() transform_number(money + bonus, resultmode_total_group, (150 + 182, 395)) resultmode_total_group.draw(main_screen) pygame.display.flip() if data['high score'] < result: data['high score'] = result data['money'] += money + bonus
def render_center_info(board_render): center_info_surface = Surface((250, 250)) match = board_render.match group = LayeredUpdates() # Background info_rect = Rect(0, 0, 250, 250) info_rect.center = board_render.surface.get_rect().center pygame.draw.rect(center_info_surface, (0, 0, 0), info_rect) current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 30) large_font = Font(font_path, 42) # Round Title round_text = "{} {}".format("East" if match.east_prevalent else "South", match.round_number) round_surface = font.render(round_text, True, (255, 255, 255)) round_sprite = Sprite() round_sprite.image = round_surface round_sprite.rect = round_surface.get_rect() round_sprite.rect.center = info_rect.center round_sprite.rect.y -= (round_surface.get_rect().height // 2) round_sprite.layer = 1 group.add(round_sprite) # Tiles Left in Wall tile_count_surface = large_font.render(str(len(match.current_board.wall)), True, (255, 255, 255)) wall_remaining_sprite = Sprite() wall_remaining_sprite.image = tile_count_surface wall_remaining_sprite.rect = tile_count_surface.get_rect() wall_remaining_sprite.rect.center = info_rect.center wall_remaining_sprite.rect.y += (tile_count_surface.get_rect().height // 3) wall_remaining_sprite.layer = 1 group.add(wall_remaining_sprite) # Wind Markers create_wind_markers(match, info_rect, group) # Turn Marker create_turn_marker(match, info_rect, group) # Riichi Markers create_riichi_markers(match, info_rect, group) background_sprite = Sprite() background_sprite.rect = info_rect background_sprite.image = center_info_surface background_sprite.layer = 0 group.add(background_sprite) return group
def are_colliding(self, object_1, object_2, camera): """Return True if 2 objects collide. the objects must have texture type AnimatedTexture and function get_onscr_rect(camera)""" obj_1_sprite = Sprite() obj_1_sprite.mask = object_1.texture.get_collision_mask() obj_1_sprite.rect = object_1.get_onscr_rect(camera) obj_2_sprite = Sprite() obj_2_sprite.mask = object_2.texture.get_collision_mask() obj_2_sprite.rect = object_2.get_onscr_rect(camera) colliding = pygame.sprite.collide_mask(obj_1_sprite, obj_2_sprite) if colliding is not None: return True return False
def create_turn_marker(board, parent_rect, group): MARKER_OFFSET = 20 MARKER_WIDTH = 5 current_turn = board.current_board.current_turn if current_turn % 2 == 0: marker_size = (parent_rect.width - MARKER_OFFSET, MARKER_WIDTH) else: marker_size = (MARKER_WIDTH, parent_rect.width - MARKER_OFFSET) marker_size_half = (marker_size[0] / 2, marker_size[1] / 2) parent_half_width = parent_rect.width / 2 parent_half_height = parent_rect.height / 2 SEAT_OFFSETS = [ (0, parent_half_height - marker_size_half[1]), (parent_half_width - marker_size_half[0], 0), (0, -parent_half_height + marker_size_half[1]), (-parent_half_width + marker_size_half[0], 0), ] turn_marker_surface = Surface(marker_size) turn_marker_surface.fill((255, 255, 255)) sprite = Sprite() sprite.rect = turn_marker_surface.get_rect() sprite.image = turn_marker_surface sprite.rect.center = parent_rect.center sprite.rect.x += SEAT_OFFSETS[current_turn][0] sprite.rect.y += SEAT_OFFSETS[current_turn][1] sprite.layer = 2 group.add(sprite)
def select(self): self.selected = True select = Sprite() select.image = pygame.image.load("images/Selected.png").convert_alpha() select.rect = self.rect select._layer = 5 self.add(select)
def mark(self): self.marked = True mark = Sprite() mark.image = pygame.image.load("images/Mark.png").convert_alpha() mark.rect = self.rect mark._layer = 4 self.add(mark)
def __init__(self, tile, camera, wx=0, wy=0, color=Color(255, 255, 255)): self.size = TileService.size GameObject.__init__(self, self.size, self.size, wx, wy) sprite = Sprite() sprite.image = TileService.getTile(tile, color) sprite.rect = (wx, wy, self.size, self.size) self.addSprites(sprite, camera)
def place_unit(self, name, pos, team_id=-1): prefab = self.mod_loader.entities[name] if 'buildable' not in prefab['tags']: print(f'Trying to place non placeable: {name=}, {team_id=}') return spr = Sprite() rect = Rect((0, 0), prefab['size']) rect.center = pos spr.rect = rect if pygame.sprite.spritecollideany(spr, self.sprites): print(f'Trying to place on occupied area: {name=}, {team_id=}') return pl = self.get_player(team_id) if not pl.has_enough(prefab['cost']): print(f'Trying to place without resources: {name=}, {team_id=}') return cls = self.mod_loader.bases[prefab['base']] u = cls(self, name, pos[0], pos[1], team_id) self.sprites.add(u) self.buildings.add(u) pl.spend(prefab['cost']) self.send([Game.ClientCommands.CREATE, u.name, u.unit_id, team_id, u.get_update_args()])
def sprite(self, rect): action_sprite = Sprite() action_sprite.pygame.image.load("../images/" + self.__class__.__name__ + ".png").convert() action_sprite.rect = rect return action_sprite
def prep_lives(self): for x in range(self.stats.lives_left): temp = ImageRect(self.screen, "pac_man_right_1", 18, 18) life = Sprite() life.image = temp.image temp.rect.x = x * 18 temp.rect.bottom = self.screen_rect.bottom - 1 life.rect = temp.rect self.lives.add(life)
def _detect_fall(self): # check if player should fall off ledge falling_dummy = Sprite() falling_dummy.rect = self.rect falling_dummy.rect.bottom += 1 #print(f"falling_dummy's bottom {falling_dummy.rect.bottom}") return len( pygame.sprite.spritecollide(falling_dummy, self.environment.platforms, False)) == 0
def test_collide_hit_rect_with_rect(self) -> None: player = make_player() pos = player.pos x = pos.x y = pos.y wall_sprite = Sprite([self.groups.walls]) wall_sprite.rect = Rect(x, y, 30, 30) self.assertTrue(collide_hit_rect_with_rect(player, wall_sprite))
def create_grid(self, layer_id, group): layer_level = self.mapa_atual["layers"][layer_id] index_item = -1 for celula in layer_level["grid"]: index_item += 1 if celula == '0': continue y = index_item // layer_level["gridCellsY"] x = index_item % layer_level["gridCellsX"] celula_bloco = Sprite(group) celula_bloco.image = scale( self.tilemap_level.clip_sprite(0, 0, 16, 16), (32, 32)) celula_bloco.rect = Rect(x * 32, y * 32, 32, 32)
def create_wind_markers(match, parent_rect, group): current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 40) MARKER_SIZE = (40, 40) MARKER_SIZE_HALF = (MARKER_SIZE[0] / 2, MARKER_SIZE[1] / 2) MARKER_OFFSET = 40 parent_half_width = parent_rect.width / 2 parent_half_height = parent_rect.height / 2 SEAT_OFFSETS = [ (0, parent_half_height - MARKER_SIZE_HALF[1] - MARKER_OFFSET), (parent_half_width - MARKER_SIZE_HALF[0] - MARKER_OFFSET, 0), (0, -parent_half_height + MARKER_SIZE_HALF[1] + MARKER_OFFSET), (-parent_half_width + MARKER_SIZE_HALF[0] + MARKER_OFFSET, 0), ] WIND_ORDERS = [ ["E", "S", "W", "N"], ["N", "E", "S", "W"], ["W", "N", "E", "S"], ["S", "W", "N", "E"], ] current_east_seat = match.current_board.current_dealer wind_order = WIND_ORDERS[current_east_seat] for i in range(4): wind = wind_order[i] background_surface = Surface(MARKER_SIZE) if i == current_east_seat: background_color = (255, 0, 0) else: background_color = (100, 100, 100) background_surface.fill(background_color) font_surface = font.render(wind, True, (255, 255, 255)) font_width, font_height = font.size(wind) background_surface.blit( font_surface, ((MARKER_SIZE[0] - font_width) / 2, (MARKER_SIZE[1] - font_height) / 2), ) sprite = Sprite() sprite.rect = background_surface.get_rect() sprite.image = background_surface sprite.rect.center = parent_rect.center sprite.rect.x += SEAT_OFFSETS[i][0] sprite.rect.y += SEAT_OFFSETS[i][1] sprite.layer = 2 group.add(sprite)
def test_y_wall_collisions(self) -> None: player = make_player() hit_rect = player.motion.hit_rect wall_sprite = Sprite([self.groups.walls]) x = player.pos.x y = player.pos.x + hit_rect.height / 2 + 1 wall_sprite.rect = Rect(x, y, 30, 30) self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite)) player.motion.vel.y = 10 player.update() self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite)) self.assertEqual(player.motion.vel.y, 0)
def start_menumode(): global fon, menumode_start_btn, menumode_info_btn, menumode_shop_btn, jar, all_sprites, process_mode, menumode_money_sprites global menumode_high_score_sprites, background_music_playing process_mode = 'menu' fon = pygame.transform.scale( pygame.image.load('data/images/menu/main_menu.png'), (width, height)) main_screen.blit(fon, (0, 0)) menumode_start_btn = StartButton() menumode_info_btn = InfoButton() menumode_shop_btn = ShopButton() jar = MenuJar() all_sprites = Group() all_sprites.add(menumode_start_btn) all_sprites.add(menumode_info_btn) all_sprites.add(menumode_shop_btn) all_sprites.add(jar) menumode_money_sprites = Group() transform_number(data['money'], menumode_money_sprites, (90, 20)) menumode_money_sprites.draw(main_screen) menumode_high_score_sprites = Group() x = 1000 - 25 * (len(str(data['high score'])) + 1) transform_number(data['high score'], menumode_high_score_sprites, (x, 20)) menumode_high_score_sprites.draw(main_screen) high_score = Sprite() high_score.image = pygame.image.load('data/Images/menu/high_score.png') high_score.mask = pygame.mask.from_surface(high_score.image) high_score.rect = high_score.image.get_rect() high_score.mask = pygame.mask.from_surface(high_score.image) high_score.rect.x = 760 - 25 * (len(str(data['high score'])) - 1) high_score.rect.y = 20 all_sprites.add(high_score) all_sprites.draw(main_screen) pygame.display.flip() if not background_music_playing: pygame.mixer.music.load('data/Music/Background.mp3') pygame.mixer.music.play(-1) background_music_playing = True
def run_game(): """ The main function""" # Initialize the game and create a screen object. os.environ['SDL_VIDEO_CENTERED'] = '1' pygame.init() settings = Settings() screen = pygame.display.set_mode( (settings.screen_width, settings.screen_height)) pygame.display.set_caption('Houtou Project') screen_sprite = Sprite() screen_sprite.rect = screen.get_rect() keys = Keys() # Create the player with her bullet group. player = Player(screen) # Create the list of enemies. enemies = [] # Load the enemies. enemy_repo = EnemyRepo(screen) bullets_list = [] # Initialize the clock. clock = Clock() ticks = 0 # Start the main loop. while True: gf.check_events(player, keys) gf.check_ticks(ticks, enemies, enemy_repo) # Update the player and the enemies. player.update() for enemy in enemies.copy(): if enemy.update(player): enemies.remove(enemy) enemy.check_ticks(player) # Update the bullets. bullets_list = gf.get_bullets_list(player, enemies) gf.update_bullets(screen_sprite, bullets_list) # Update the screen. gf.update_screen(screen, settings, player, enemies, bullets_list) clock.tick(settings.fps) ticks += 1
def create_riichi_markers(match, parent_rect, group): MARKER_OFFSET = 60 MARKER_Y_OFFSET = 10 MARKER_WIDTH = 15 i = -1 for player in match.players: i += 1 if not player.riichi_declared: continue if i % 2 == 0: marker_size = (parent_rect.width - MARKER_OFFSET, MARKER_WIDTH) else: marker_size = (MARKER_WIDTH, parent_rect.width - MARKER_OFFSET) marker_size_half = (marker_size[0] / 2, marker_size[1] / 2) parent_half_width = parent_rect.width / 2 parent_half_height = parent_rect.height / 2 SEAT_OFFSETS = [ (0, parent_half_height - marker_size_half[1] - MARKER_Y_OFFSET), (parent_half_width - marker_size_half[0] - MARKER_Y_OFFSET, 0), (0, -parent_half_height + marker_size_half[1] + MARKER_Y_OFFSET), (-parent_half_width + marker_size_half[0] + MARKER_Y_OFFSET, 0), ] riichi_marker_surface = Surface(marker_size) marker_rect = riichi_marker_surface.get_rect() riichi_marker_surface.fill((255, 255, 255)) pygame.draw.circle( riichi_marker_surface, (255, 0, 0), (marker_rect.width / 2, marker_rect.height / 2), 5, ) sprite = Sprite() sprite.rect = marker_rect sprite.image = riichi_marker_surface sprite.rect.center = parent_rect.center sprite.rect.x += SEAT_OFFSETS[i][0] sprite.rect.y += SEAT_OFFSETS[i][1] sprite.layer = 2 group.add(sprite)
def __init__(self, tile, camera, wx=0, wy=0, color=Color(255,255,255)): self.size = TileService.size GameObject.__init__(self, self.size, self.size, wx, wy) sprite = Sprite() sprite.image = TileService.getTile(tile, color) sprite.rect = ( wx, wy, self.size, self.size ) self.addSprites(sprite, camera) Keyboard.on(Keyboard.keymap['TICK'], self.passTurn, CHARACTER_INPUT_GROUP) Keyboard.on(Keyboard.keymap['MOVE_UP'], partial(self.moveCharacter,0,-1*self.size), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_RIGHT'], partial(self.moveCharacter,1*self.size,0), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_LEFT'], partial(self.moveCharacter,-1*self.size,0), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_DOWN'], partial(self.moveCharacter,0,1*self.size), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_UP_RIGHT'], partial(self.moveCharacter,1*self.size,-1*self.size), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_UP_LEFT'], partial(self.moveCharacter,-1*self.size,-1*self.size), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_DOWN_RIGHT'], partial(self.moveCharacter,1*self.size,1*self.size), CHARACTER_INPUT_GROUP); Keyboard.on(Keyboard.keymap['MOVE_DOWN_LEFT'], partial(self.moveCharacter,-1*self.size,1*self.size), CHARACTER_INPUT_GROUP);
def render_bot_icons(board_render): ICON_SIZE = (50, 50) group = LayeredUpdates() SEAT_POS = [ None, (board_render.surface.get_width() - ICON_SIZE[0] - 10, 80), (460 - ICON_SIZE[0] - 10, 10), (10, 80) ] game_view = board_render.match.game_manager.get_active_view() icon_cache = game_view.bot_icon_cache ais = game_view.ai_list ai_icons = [] dud_ai_icon = pygame.Surface(ICON_SIZE, pygame.SRCALPHA) load_image_resource("dudB.png", dud_ai_icon, size=ICON_SIZE) for i in range(4): for icon in icon_cache: if icon['ai'] == ais[i]: surface = pygame.Surface(ICON_SIZE, pygame.SRCALPHA) load_image_resource(icon['icon'], surface, size=ICON_SIZE) ai_icons += [surface] break is_story_mode = hasattr(game_view, "match_dict") for seat in range(4): if seat == 0: continue sprite = Sprite() sprite.rect = (SEAT_POS[seat], ICON_SIZE) sprite.layer = 0 if is_story_mode and seat != 2: sprite.image = dud_ai_icon else: sprite.image = ai_icons[seat] group.add(sprite) return group
# init pygame and create window pygame.init() # init sound mixer pygame.mixer.init() screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("A game that doesn't work") clock = pygame.time.Clock() all_sprites = pygame.sprite.Group() player = Player() # player2 = Player() testSprite = Sprite() testSprite.image = pygame.Surface((50,50)) testSprite.image.fill(GREEN) testSprite.rect = testSprite.image.get_rect() testSprite.rect.center = (WIDTH / 2, HEIGHT / 2) # all_sprites.add(player) # all_sprites.add(player2) # all_sprites.add(testSprite) for i in range(0,1): i = Player() i.rect[0] = random.randint(0,WIDTH) i.rect[1] = random.randint(0,HEIGHT) all_sprites.add(i) class Enemy(Sprite): # sprite for enemy # properties of the class def __init__(self):
def collapse_layer(old_layer, new_layer, num_tiles=(2, 2)): """Collapse a single layer by joining num_tiles into one tile. A new layer is returned. The old_layer argument is the layer to process. The new_layer argument is the layer to build. The num_tiles argument is a tuple representing the number of tiles in the X and Y axes to join. If a map area is sparse (fewer tiles than num_tiles[0] * num_tiles[1]) the tiles will be kept as they are. If tiles with different characteristics are joined, the results can be unexpected. These characteristics include some flags, depth, colorkey. This can be avoided by pre-processing the map to convert all images so they have compatible characteristics. """ from pygame.sprite import Sprite from gummworld2 import Vec2d # New layer dimensions. num_tiles = Vec2d(num_tiles) tw, th = (old_layer.tile_width, old_layer.tile_height) * num_tiles mw, mh = (old_layer.width, old_layer.height) // num_tiles if mw * num_tiles.x != old_layer.pixel_width: mw += 1 if mh * num_tiles.y != old_layer.pixel_height: mh += 1 # Poke the right values into new_layer. cell_size = max(tw, th) * 2 new_layer.objects = spatialhash.SpatialHash(cell_size) new_layer.width = mw new_layer.height = mh new_layer.tile_width = tw new_layer.tile_height = th # Grab groups of map sprites, joining them into a single larger image. query_rect = pygame.Rect(0, 0, tw - 1, th - 1) for y in range(0, mh * th, th): for x in range(0, mw * tw, tw): query_rect.topleft = x, y sprites = old_layer.objects.intersect_entities(query_rect) if len(sprites) != num_tiles.x * num_tiles.y: for s in sprites: new_layer.add(s) continue # If sprite images have different characteristics, they cannot be # reliably collapsed. In which case, keep them as-is. # incompatible = False image = sprites[0].image flags = image.get_flags() ^ pygame.SRCALPHA colorkey = image.get_colorkey() depth = image.get_bitsize() # This is probably too restrictive. However, some combinations of tiles may # give funky results. # all_details = (flags,colorkey,depth) # for s in sprites[1:]: # if all_details != ( # s.image.get_flags(), # s.image.get_colorkey(), # s.image.get_bitsize(), # ): # incompatible = True # if incompatible: # print('collapse_layer: incompatible image characteristics') # for s in sprites: # new_layer.add(s) # continue # Make a new sprite. new_sprite = Sprite() new_sprite.rect = sprites[0].rect.unionall([s.rect for s in sprites[1:]]) new_sprite.rect.topleft = x, y new_sprite.image = pygame.surface.Surface(new_sprite.rect.size, flags, depth) if colorkey: new_sprite.image.set_colorkey(colorkey) # Blit (x,y) tile and neighboring tiles to right and lower... left = reduce(min, [s.rect.x for s in sprites]) top = reduce(min, [s.rect.y for s in sprites]) for sprite in sprites: p = sprite.rect.x - left, sprite.rect.y - top new_sprite.image.blit(sprite.image.convert(depth, flags), p) new_layer.add(new_sprite) return new_layer
def start_gameplay(): global all_sprites, background, jar, process_mode, bombs, bomb_type, gameplay_time global gameplay_score_counter, gameplay_bombs_counter, gameplay_money_counter, gameplay_health_group global gameplay_score, gameplay_bombs_number, gameplay_bomb_symbol, gameplay_money global gameplay_money_symbol, gameplay_health, gameplay_pause, clock, gameplay_enemies global gameplay_enemies_period, gameplay_wall, background_music_playing, gameplay_clouds process_mode = 'game' all_sprites = Group() clock = pygame.time.Clock() background = Background() all_sprites.add(background) jar = Jar(1) all_sprites.add(jar) bombs = Group() bomb_type = 'apple' gameplay_score = 0 gameplay_score_counter = Group() transform_number(gameplay_score, gameplay_score_counter, (3, 3)) gameplay_score_counter.draw(main_screen) gameplay_bombs_number = 500 gameplay_bomb_symbol = BombSymbol() all_sprites.add(gameplay_bomb_symbol) gameplay_bombs_counter = Group() transform_number(gameplay_bombs_number, gameplay_bombs_counter, (200, 3)) gameplay_bombs_counter.draw(main_screen) gameplay_money = 0 gameplay_money_symbol = MoneySymbol() all_sprites.add(gameplay_money_symbol) gameplay_money_counter = Group() transform_number(gameplay_money, gameplay_money_counter, (370, 3)) gameplay_score_counter.draw(main_screen) gameplay_health = HealthGroup() gameplay_health.draw(main_screen) gameplay_wall = Sprite() gameplay_wall.image = pygame.Surface([1, 650]) gameplay_wall.rect = pygame.Rect(-1, 0, 1, 650) gameplay_pause = PauseBtn() all_sprites.add(gameplay_pause) all_sprites.draw(main_screen) gameplay_enemies = Group() gameplay_time = 0 gameplay_enemies_period = 1.5 pygame.display.flip() pygame.mixer.music.load('data/Music/The Ride of the Valkyries.mp3') pygame.mixer.music.play(-1) background_music_playing = False gameplay_clouds = Group()
while running: if process_mode == 'game': for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE and gameplay_bombs_number > 0: bombs.add(Bomb(jar.rect.y, bomb_type)) gameplay_bombs_number -= 1 gameplay_bombs_counter.empty() transform_number(gameplay_bombs_number, gameplay_bombs_counter, (200, 3)) elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: click_sprite = Sprite() click_sprite.rect = pygame.Rect(event.pos[0], event.pos[1], 1, 1) click_group = Group() click_group.add(click_sprite) if gameplay_pause.update(click_group) == 'pause': start_pausemode() click_group.empty() if process_mode == 'game': buttons = pygame.key.get_pressed() buttons = [buttons[i] for i in (273, 274, 32, 304)] time = clock.tick() / 1000 background.update(time) jar.update(buttons, time) bombs.update(time) all_sprites.draw(main_screen)
def render_score_screen(board_render): should_show_screen = board_render.board_manager.round_should_end group = LayeredUpdates() if not should_show_screen: return group current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 40) font_small = Font(font_path, 24) match = board_render.match scores = match.scores delta_scores = match.delta_scores total_scores = list(map(lambda s: s[0] + s[1], zip(scores, delta_scores))) winner_indices = numpy.argwhere(numpy.array(delta_scores) > 0).flatten() winner_names = [] array = numpy.array(total_scores) temp = array.argsort()[::-1] ranks = numpy.empty_like(temp) ranks[temp] = numpy.arange(len(array)) icons = get_object('boticons')['bot'] screen_surface = Surface(board_render.surface.get_size(), pygame.SRCALPHA) screen_surface.fill((0, 0, 0)) ROUND_COMPLETE = "Round Complete" round_complete_surface = font.render(ROUND_COMPLETE, True, (255, 255, 255)) font_width, font_height = font.size(ROUND_COMPLETE) icon_size = (100, 100) player_list = match.ai_list x = screen_surface.get_width() // 5 y = font_height + 5 for seat in range(4): ai_name = player_list[seat] name = None icon = None for entry in icons: if entry['ai'] == ai_name: name = entry['name'] icon = entry['icon'] break if name is None: raise "BOT WAS NOT DEFINED." if seat in winner_indices: winner_names += [name] icon_surface = Surface(icon_size, pygame.SRCALPHA) load_image_resource(icon, icon_surface, size=icon_size) screen_surface.blit( icon_surface, (x, y) ) player_name = font.render(name, True, (255, 255, 255)) _, name_h = font.size(name) screen_surface.blit( player_name, (x + icon_size[0] + 10, y) ) score_string = "{} Points".format(scores[seat]) score_render = font_small.render(score_string, True, (255, 255, 255)) _, score_h = font_small.size(score_string) screen_surface.blit( score_render, (x + icon_size[0] + 10, y + name_h + 5) ) delta_string = "{}{}".format("+" if delta_scores[seat] >= 0 else "", delta_scores[seat]) delta_render = font_small.render(delta_string, True, (255, 255, 255)) _, delta_h = font_small.size(delta_string) screen_surface.blit( delta_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5) ) total_string = "Total: {} Points".format(total_scores[seat]) total_render = font_small.render(total_string, True, (255, 255, 255)) screen_surface.blit( total_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5 + delta_h + 5) ) place_string = "{}".format(ranks[seat] + 1) place_render = font.render(place_string, True, (255, 255, 255)) place_w, place_h = font.size(place_string) screen_surface.blit( place_render, (x - place_w - 5, y + ((icon_size[1] - place_h) // 2)) ) y += icon_size[1] + 70 LOADING_NEXT_ROUND = "Loading next Round..." loading_surface = font.render(LOADING_NEXT_ROUND, True, (255, 255, 255)) loading_width, loading_height = font.size(LOADING_NEXT_ROUND) screen_surface.blit( loading_surface, (screen_surface.get_width() - loading_width - 10, screen_surface.get_height() - loading_height - 10) ) screen_surface.blit( round_complete_surface, ((screen_surface.get_width() // 2) - (font_width // 2), 10), ) result_pos = (screen_surface.get_width() * 0.6, screen_surface.get_height() // 3) if board_render.board_manager.did_exhaustive_draw: EXHAUSTIVE = "Exhaustive Draw" exhaustive_surface = font.render(EXHAUSTIVE, True, (255, 255, 255)) screen_surface.blit( exhaustive_surface, result_pos ) else: WINNERS = "Winners:" winners = ", ".join(winner_names) winner_text = font_small.render(WINNERS, True, (255, 255, 255)) winner_name_text = font_small.render(winners, True, (255, 255, 255)) screen_surface.blit( winner_text, result_pos ) screen_surface.blit( winner_name_text, (result_pos[0], result_pos[1] + winner_text.get_rect().height + 5) ) background_sprite = Sprite() background_sprite.rect = screen_surface.get_rect() background_sprite.image = screen_surface background_sprite.layer = 0 group.add(background_sprite) return group
def collide_cursor(self, cursor_pos): cursor = Sprite() cursor.rect = Rect((int(cursor_pos[0] - self.camera.offset_x), int(cursor_pos[1] - self.camera.offset_y)), (1, 1)) return pygame.sprite.spritecollide(cursor, self.sprites, False)
def getShadow(self): shadow = Sprite() shadow.rect = self.lastRect.move(0,0) return shadow
window = pygame.display.set_mode((600, 400)) screen = pygame.Surface((600, 400)) clock = pygame.time.Clock() inGame = True im = pygame.image.load('images\\brick.png') im2 = pygame.image.load('images\\q1.png') g = Group() # Первый способ s = Sprite() s.image = im s.rect = s.image.get_rect() s.rect.topleft = 100, 150 s.add(g) # Второй способ class Obj(Sprite): def __init__(self, im, x, y): Sprite.__init__(self) self.image = im self.rect = self.image.get_rect() self.rect.topleft = x, y self.add(g) class Im(Obj):
def getShadow(self): shadow = Sprite() shadow.rect = self.lastRect.move(0, 0) return shadow
def new_sprite(image, rect): sprite = Sprite() sprite.image = image sprite.rect = rect return sprite
present = personat(x/8, y/8) if shownoise and not present: continue sprite = Sprite() sprite.image = Surface((4,4), flags=SRCALPHA) if present: sprite.exists = True male = sex(x/8,y/8) draw.circle(sprite.image, (196,196,255) if male else (255,196,196), (2,2), 2, 1 if shownoise else 0) else: sprite.exists = False if not shownoise: draw.circle(sprite.image, (128,128,128), (2,2), 2, 1) sprite.rect = sprite.image.get_rect().move(x, y) sprites.add(sprite) limit = Clock() done = False def family(generation, index): fam = 0 infam = False for i in range(0, index): if personat(generation, i): if not infam: infam = True else: if infam:
def _load_tiled_tmx_map(tmx_map, gummworld_map, load_invisible=True): """Load an orthogonal TMX map file that was created by the Tiled Map Editor. If load_invisible is False, layers where visible!=0 will be empty. Their tiles will not be loaded. Thanks to DR0ID for his nice tiledtmxloader module: http://www.pygame.org/project-map+loader+for+%27tiled%27-1158-2951.html And the creators of Tiled Map Editor: http://www.mapeditor.org/ """ # Taken pretty much verbatim from the (old) tiledtmxloader module. from pygame.sprite import Sprite resource = ResourceLoaderPygame() resource.load(tmx_map) tile_size = (tmx_map.tilewidth, tmx_map.tileheight) map_size = (tmx_map.width, tmx_map.height) for layeri,layer in enumerate(tmx_map.layers): gummworld_layer = TiledLayer(gummworld_map, layer, layeri) gummworld_map.layers.append(gummworld_layer) if not layer.visible and not load_invisible: continue if layer.is_object_group: for obj in layer.objects: sprite = Sprite() sprite.image = obj.image sprite.rect = pygame.Rect(obj.x, obj.y, obj.width, obj.height) sprite.type = obj.type sprite.image_source = obj.image_source sprite.name = obj.name sprite.properties = obj.properties gummworld_layer.add(sprite) else: for ypos in xrange(0, layer.height): for xpos in xrange(0, layer.width): x = (xpos + layer.x) * layer.tilewidth y = (ypos + layer.y) * layer.tileheight img_idx = layer.content2D[xpos][ypos] if img_idx == 0: continue try: offx,offy,tile_img = resource.indexed_tiles[img_idx] screen_img = tile_img except KeyError: print 'KeyError',img_idx,(xpos,ypos) continue sprite = Sprite() ## Note: alpha conversion can actually kill performance. ## Do it only if there's a benefit. # if convert_alpha: # if screen_img.get_alpha(): # screen_img = screen_img.convert_alpha() # else: # screen_img = screen_img.convert() # if layer.opacity > -1: # screen_img.set_alpha(None) # alpha_value = int(255. * float(layer.opacity)) # screen_img.set_alpha(alpha_value) # screen_img = screen_img.convert_alpha() sprite.image = screen_img sprite.rect = screen_img.get_rect(topleft=(x + offx, y + offy)) sprite.name = xpos,ypos gummworld_layer.add(sprite)
def rotateObject(obj: Sprite, angle): center = obj.rect.center obj.rot_angle = (obj.rot_angle + angle) % 360 obj.image = pygame.transform.rotate(obj.image_org, obj.rot_angle) obj.rect = obj.image.get_rect(center=center)