def goom_surface_update(self): """ The timer handler Uses a state machine to control the display of the cover image """ #_debug_('goom_surface_update()') try: # draw the cover if not self.running: return False if self.mode == MpvMode.FULL: if self.message_counter == 0: print('%s.message=%r' % (self.__class__, self.message)) if self.message: self.set_message(self.message) self.message_counter = (self.message_counter + 1) % config.MPLAYERVIS_MSG_FRAMES gooms = self.goom.process() # write the goom surface to the display if self.mode == MpvMode.FULL: zoom = 2 ** config.MPLAYERVIS_FULL_ZOOM for i in range(config.MPLAYERVIS_FULL_ZOOM): gooms = transform.scale2x(gooms) self.rect.width = gooms.get_width() self.rect.height = gooms.get_height() #print 'zoom=%r %r rect=%r' % (zoom, range(config.MPLAYERVIS_FULL_ZOOM), self.rect) #DJW elif self.mode == MpvMode.DOCK: zoom = 2 ** config.MPLAYERVIS_DOCK_ZOOM for i in range(config.MPLAYERVIS_DOCK_ZOOM): gooms = transform.scale2x(gooms) self.rect.width = gooms.get_width() self.rect.height = gooms.get_height() #print 'zoom=%r %r rect=%r' % (zoom, range(config.MPLAYERVIS_DOCK_ZOOM), self.rect) #DJW if self.showfps: self.goom.fps = self.clock.get_fps() else: self.goom.fps = -1 if self.coversurf: self.state() if self.alpha > 0: s, x, y = self.coversurf logger.log( 9, 'self.alpha=%r', self.alpha) s.set_alpha(self.alpha) logger.log( 9, 'gooms.blit(s=%r, (x=%r, y=%r))', s, x, y) gooms.blit(s, (x, y)) if self.mode == MpvMode.FULL: self.draw_info(gooms) osd.putsurface(gooms, self.rect.left, self.rect.top) osd.update(self.rect) self.clock.tick() return True except Exception, why: traceback.print_exc() logger.warning(why)
def test_scale(surface): """Simple scale tests""" obj = _make_object() surface.blit(obj, (20, 20)) obj1 = transform.scale(obj, (100, 100)) surface.blit(obj1, (80, 80)) obj2 = transform.scale(obj1, (60, 60)) surface.blit(obj2, (160, 160)) obj3 = transform.scale(obj, (60, 60)) surface.blit(obj3, (240, 160)) obj1 = transform.scale2x(obj) surface.blit(obj1, (240, 240)) obj1 = transform.scale2x(obj2) surface.blit(obj1, (320, 320))
def image_at(self, rect, colorkey=None, scale2x=False, flip=False, alpha=False): if alpha: image = Surface(rect.size, SRCALPHA) image.blit(self.image, (0, 0), rect) else: image = Surface(rect.size).convert() image.blit(self.image, (0, 0), rect) if colorkey is not None: if colorkey == -1: colorkey = image.get_at((0, 0)) image.set_colorkey(colorkey, RLEACCEL) if flip == 'x': image = transform.flip(image, True, False) elif flip == 'y': image = transform.flip(image, False, True) if scale2x: image = transform.scale2x(image) return image
def __init__(self, folder: str, numFrame: int) -> None: # region DocString """ Creates a `Animation` object ### Arguments `folder {str}`: `summary`: the folder containing the frames `numFrame {int}`: `summary`: number of frames in the animation """ # endregion self.frames = [] # region Load frames for i in range(numFrame): s = load(f"{folder}/{i}.png").convert_alpha() s = scale2x(s) self.frames.append(s) # endregion self.index = 0 self.len = len(self.frames)
def __init__(self, config): from pygame import image, transform # IMAGES self.background_img = image.load(config.BACKGROUND).convert() self.background_img = transform.scale(self.background_img, config.SCREEN_SIZE) self.croshair_img = image.load(config.CROSHAIR).convert() self.croshair_img.set_colorkey((63, 72, 204)) self.bogey_img = image.load(config.BOGEY).convert() self.bogey_img.set_colorkey((63, 72, 204)) self.missile_img = image.load(config.MISSILE).convert() self.missile_img.set_colorkey((63, 72, 204)) self.splash_img = image.load(config.SPLASH).convert() self.splash_img.set_colorkey((63, 72, 204)) self.ship_img = image.load(config.SHIP).convert() self.ship_img = transform.scale2x(self.ship_img) self.ship_img.set_colorkey((63, 72, 204)) ### Highlite self.highlite_img = image.load(config.HIGHLITE).convert() self.highlite_img.set_colorkey((163, 73, 164))
def play_animation(self, frames, surfaces=None): if surfaces is None: if self.current_frame >= frames - 1: self.current_frame = 0 self.animate = False elif self.current_frame < frames and surfaces is None: self.current_frame += 1 new_area = (self.current_frame * self.rect.width, 0, self.rect.width, self.rect.height) # Ver que sólo se cambia la imagen, no es necesario volver a obtener el rectángulo porque ya está definido center = self.rect.center self.image = self.animation_sheet.subsurface(new_area) elif surfaces is not None: # La animación no repetirá el ciclo aquí, sino que finalizará en el sprite final if self.current_frame >= self.frames - 1: self.animate = False else: self.current_frame += 1 center = self.rect.center self.image = transform.scale2x(self.animation_sheet.subsurface(surfaces[self.current_frame])) self.rect = self.image.get_rect() self.rect.center = center return self.animate
def __init__(self, position): sprite.Sprite.__init__(self) self.frames = [transform.scale2x(image.load("explosion%d.png" % i)) for i in xrange(0,3)] self.image = self.frames[0] self.rect = self.image.get_rect() self.rect.center = position self.index = 0 explosion_sound.play()
def add_sprites(self): for row in range(1, self.rows): for block in range(1, self.blocks): key = random.choice(list(self.color_dict.keys())) random_block_color = self.color_dict[key] sprite_type = key # PASO 1: CREAR SPRITE A PARTIR DE SPRITE SHEET RECORTADA, DEFINIENDO SU POSICIÓN # PASO 1.1: RECORTAR ÁREA DE LA IMAGEN PARA HACERLA COINCIDIR CON EL BLOQUE CORRESPONDIENTE # Y REESCALAR AL DOBLE # El tercer valor del rectángulo corresponde a su ancho. Habrá que ver si es de una lista de sprites # de una animación o si ésta corresponde a un bloque individual if random_block_color[2] > 16: # Estos bloques pueden ser permanentes (GD) o desaparecer tras el segundo golpe (SV) # Además, son animables, cada elemento de la lista equivale a un fotograma de la animación, por lo # que se carga aparte. # Estos bloques tendrán una variable extra para almacenar los sprites de la animación en una nueva # subsuperficie. animation_sheet = transform.scale2x(image.load(self.sprite_sheet).convert().subsurface(Rect(random_block_color))) block_sprite = sprite_factory.SpriteFactory(self.sprite_sheet, sprite_type=sprite_type, animation_sheet=animation_sheet, frames=6) # Cogemos el primer fotograma para que sea la imagen general que se muestra mientras no se active la # reproducción de la animación. block_sprite_area = (random_block_color[0], random_block_color[1], random_block_color[2] // block_sprite.frames, random_block_color[3]) block_sprite.image = transform.scale2x(block_sprite.image.subsurface(Rect(block_sprite_area))) else: # Estos bloques desaparecen block_sprite = sprite_factory.SpriteFactory(self.sprite_sheet, sprite_type=sprite_type) block_sprite.image = transform.scale2x(block_sprite.image.subsurface(Rect(random_block_color))) # Master image para reescalados sin pérdidas block_sprite.block_image_master = block_sprite.image if block_sprite.animation_sheet is not None: block_sprite.animation_sheet_master = block_sprite.animation_sheet # PASO 2: UBICAR SPRITE block_sprite.rect = block_sprite.image.get_rect() block_sprite.rect.x = block_sprite.rect.width * block block_sprite.rect.y = block_sprite.rect.height * row + self.grid_height * 2 # Para reubicar elementos en el reescalado block_sprite.position_master = block_sprite.rect.topleft # PASO 3: AÑADIR SPRITE AL GRUPO self.add(block_sprite) return self
def main(): screen = pygame.display.set_mode((1024, 768)) pygame.display.init() input_image_name = sys.argv[1] result = scale2x(image.load(input_image_name).convert_alpha()) path, name = p.split(input_image_name) old_name, ext = p.splitext(name) new_name = old_name + "2x" + ext new_path = p.join(path, new_name) image.save(result, new_path)
def __init__(self, imagefilename, initialpos): sprite.Sprite.__init__(self) self.baseimage = self.image = transform.scale2x(image.load(imagefilename)) self.rect = self.image.get_rect(); self.realpos = initialpos self.rect.center = self.realpos self.acceleration_magnitude = 0.0 self.rotation = math.pi / 2.0 self.velocity = [0,0] self.acceleration = [0,0]
def flip(self, delay=True): if self._scale_type == 'scale2x': tmpsurf = self target_width = self._target.get_width() while tmpsurf.get_width() < target_width: tmpsurf = transform.scale2x(tmpsurf) self._target.blit(tmpsurf, (0,0)) else: self._scale_function(self, self._target.get_size(), self._target) if delay: self.limit_fps() display.flip() self._update_rects = []
def draw(self, screen): screen.fill(BLACK) first = self.waves[0] amp = mapf(first.amp, b=(0, self.scale)) draw.aalines(screen, DARKER_GREY, True, [(x - amp * cos(first.phase), y - amp * sin(first.phase)) for x, y in self.origin_path]) origin = self.MIDDLE if not self.stop: for wave in self.waves[1:]: radius = mapf(wave.amp, b=(0, self.scale)) gfxdraw.aacircle(screen, int(origin.x), int(origin.y), int(max(2, radius)), GREY) angle = self.t * wave.freq + wave.phase end_point = origin + (radius * cos(angle), radius * sin(angle)) draw.aaline(screen, WHITE, origin.int_tuple, end_point.int_tuple) origin = end_point self.trail.append(origin) length = len(self.trail) if length > 1: if self.teleport: prev = self.trail[0] for i in self.trail[1:]: if prev.dist(i) < 10: draw.aaline(screen, NICE_RED, prev.float_tuple, i.float_tuple) prev = i else: draw.aalines(screen, NICE_RED, False, list(map(lambda x: x.float_tuple, self.trail))) if not self.stop: self.t += self.dt if length > self.trail_length + 15: self.stop = True if self.zoom: scaled = transform.scale2x(screen) screen.fill(BLACK) screen.blit(scaled, (self.size[0] / 2 - origin.x * 2, self.size[1] / 2 - origin.y * 2)) font = pygame.font.Font("NanumSquare.ttf", 17) text = font.render("https://github.com/pl-Steve28-lq", True, WHITE) rect = text.get_rect() rect.x = 10 rect.y = int(self.size[1] - rect.size[1] * 3 / 2) screen.blit(text, rect)
def generate_size(self, size): if size == self.size: return self result = ModelSet(size) for surf in self.front: result.front.append(transform.scale2x(surf)) for surf in self.back: result.back.append(transform.scale2x(surf)) for surf in self.left: result.left.append(transform.scale2x(surf)) for surf in self.right: result.right.append(transform.scale2x(surf)) for surf in self.ground_up: result.ground_up.append(transform.scale2x(surf)) for surf in self.ground_down: result.ground_down.append(transform.scale2x(surf)) return result
def __init__(self, images, font): super(Title_Screen, self).__init__() self.images = images self.image = self.images['sky'].copy() self.font = font self.rect = self.image.get_rect() title = self.font.render('WIZARDS', False, (70, 0, 6)) title = scale2x(title) self.image.blit(title, (title.get_rect( center=(self.rect.centerx, self.rect.height // 3)))) self.opts = ['PLAY', 'QUIT', 'TEST'] self.assoc = {k: v for k, v in enumerate(self.opts)} self.opt_rects = [] self.blit_opts()
def __init__(self, *groups): #: pygame.AbstractGroup): super().__init__(*groups) self.image = image.load('res/image/gui/curs.png') self.textures = { 'def': scale2x(scale2x(image.load('res/image/gui/curs.png'))), 'l': scale2x(scale2x(image.load('res/image/gui/curs_l.png'))), 'r': scale2x(scale2x(image.load('res/image/gui/curs_r.png'))) } self.rect = self.image.get_rect(center=get_pos())
def __init__(self, *groups): super(Lifter, self).__init__(*groups) #self._speed = 0 self.image_base = scale2x(load(filepath('lifter.png'))).convert_alpha() self.image = self.image_base #self.mask = pygame.mask.from_surface(self.image) self.rect = pygame.Rect( (100,100), self.image.get_size()) self._xspeed = 0 self._yspeed = 0 self._rotspeed = 0 self._rotation = 0 self._sounds = { 'dead': pygame.mixer.Sound(filepath('buggy-hit.wav')), 'jump': pygame.mixer.Sound(filepath('jump.wav'))}
def command_zoom_in(new_img, new_img_width, new_img_height, img, screen, files, file, num_imgs, rect, zoom_type): wait_cursor() start = start_timer() gl.ZOOM_EXP += 1 if zoom_type == "normal": gl.ZOOM_DOULBE = 0 new_img = scale(img, (new_img.get_width() * 1.1, new_img.get_height() * 1.1)) if zoom_type == "double": gl.ZOOM_DOUBLE = 1 new_img = scale(img, (new_img.get_width() * 2, new_img.get_height() * 2)) if zoom_type == "scale2x": gl.ZOOM_DOUBLE = 1 new_img = scale2x(img) # don't alias simple solid color images (ie., black & white GIFs) rect = get_center(screen, new_img) my_update_screen(new_img, screen, rect, file, num_imgs, check_timer(start)) normal_cursor() return (new_img, img, rect)
def __init__(self, *groups): super(Lifter, self).__init__(*groups) #self._speed = 0 self.image_base = scale2x(load(filepath('lifter.png'))).convert_alpha() self.image = self.image_base #self.mask = pygame.mask.from_surface(self.image) self.rect = pygame.Rect((100, 100), self.image.get_size()) self._xspeed = 0 self._yspeed = 0 self._rotspeed = 0 self._rotation = 0 self._sounds = { 'dead': pygame.mixer.Sound(filepath('buggy-hit.wav')), 'jump': pygame.mixer.Sound(filepath('jump.wav')) }
def command_zoom_in(new_img, img, file, rect, zoom_type): wait_cursor() screen = get_surface() new_img_width = new_img.get_width() new_img_height = new_img.get_height() gl.ZOOM_EXP += 1 if zoom_type == "normal": gl.ZOOM_DOULBE = 0 new_img = scale(img, (int(new_img_width * 1.1), int(new_img_height * 1.1))) if zoom_type == "double": gl.ZOOM_DOUBLE = 1 new_img = scale(img, (new_img_width * 2, new_img_height * 2)) if zoom_type == "scale2x": gl.ZOOM_DOUBLE = 1 new_img = scale2x(img) # don't alias simple solid color images (ie., black & white GIFs) rect = get_center(screen, new_img) my_update_screen(new_img, rect, file) normal_cursor() return (new_img, img, rect)
def show(screen): global t screen.fill(BLACK) # Original path draw.aalines(screen, DARKER_GREY, True, original_path) # Epicycles origin = MIDDLE # type: Vec2d for wave in waves: # Circle radius = mapf(wave.amp, b=(0, SCALE)) #draw.circle(screen, DARK_GREY, origin.int_tuple, int(max(2, radius)), 1) gfxdraw.aacircle(screen, int(origin.x), int(origin.y), int(max(2, radius)), DARK_GREY) # Line angle = t * wave.freq + wave.phase end_point = origin + (radius * cos(angle), radius * sin(angle)) draw.aaline(screen, WHITE, origin.int_tuple, end_point.int_tuple) origin = end_point # Trail trail.append(origin.float_tuple) if len(trail) > trail_length: trail.pop(0) if len(trail) > 1: draw.aalines(screen, NICE_RED, False, trail) # Zoom if ZOOM: scaled = transform.scale2x(screen) screen.fill(BLACK) screen.blit(scaled, (WIDTH / 2 - origin.x * 2, HEIGHT / 2 - origin.y * 2)) t += dt
# imports import pygame import pygame.transform as transform import pygame.image as image import pygame.mask as mask import os # local imports BIRD_IMGS = [ transform.scale2x(image.load(os.path.join("imgs", "bird1.png"))), transform.scale2x(image.load(os.path.join("imgs", "bird2.png"))), transform.scale2x(image.load(os.path.join("imgs", "bird3.png"))) ] class Bird: IMGS = BIRD_IMGS MAX_ROTATION = 25 ROT_VEL = 20 ANIMATION_TIME = 5 def __init__(self, x, y): self.x = x self.y = y self.tilt = 0 self.tick_count = 0 self.vel = 0 self.height = self.y self.img_count = 0 self.img = self.IMGS[0]
import random # local imports import bird as bird_c import pipe as pipe_c import base as base_c # inits pygame.font.init() WIN_WIDTH = 500 WIN_HEIGHT = 800 GEN = 0 BG_IMG = transform.scale2x(image.load(os.path.join("imgs", "bg.png"))) STAT_FOMT = pygame.font.SysFont("consolas", 25) def draw_window(win, birds, pipes, base, score, gen): # background win.blit(BG_IMG, (0, 0)) # pipes for pipe in pipes: pipe.draw(win) # base base.draw(win) # bird
def update_display_scaled2x(dirty): scale2x(screen, screen_surface) flip()
def apply_scaling(image): return pytf.scale2x(image)
def scale(surface: Surface) -> Surface: from pygame.transform import scale2x return scale2x(scale2x(surface))
import pickle import os import random pygame.init() WIN_HEIGHT = 800 WIN_WIDTH = 500 GEN = 0 GAP = 200 VEL = 5 BIRD_IMGS = [] for i in range(1, 4): img = pygame.image.load(os.path.join("imgs", f"bird{i}.png")) BIRD_IMGS.append(scale2x(img)) BG_IMG = scale2x(pygame.image.load(os.path.join("imgs", "bg.png"))) PIPE_IMG = scale2x(pygame.image.load(os.path.join("imgs", "pipe.png"))) BASE_IMG = scale2x(pygame.image.load(os.path.join("imgs", "base.png"))) STAT_FONT = pygame.font.SysFont("comicsans", 50) class Base: WIDTH = BASE_IMG.get_width() IMG = BASE_IMG def __init__(self, y): self.y = y self.x1 = 0 self.x2 = self.WIDTH
# imports import pygame import pygame.transform as transform import pygame.image as image import pygame.mask as mask import os import random # local imports PIPE_IMG = transform.scale2x(image.load(os.path.join("imgs", "pipe.png"))) class Pipe: GAP = 200 VEL = 5 def __init__(self, x): self.x = x self.height = 0 self.top = 0 self.bottom = 0 self.PIPE_TOP = transform.flip(PIPE_IMG, False, True) self.PIPE_BOTTOM = PIPE_IMG self.passed = False self.set_height() def set_height(self): self.height = random.randrange(50, 450) self.top = self.height - self.PIPE_TOP.get_height()
def game(screen): _starfield = pygame.transform.scale(load(filepath('starfield.png')), (settings.DISPLAY_SIZE)).convert() _bground = load(filepath('mountains2.png')).convert_alpha() _terrain00 = scale2x(load(filepath('terrain00.png'))).convert_alpha() _terrain01 = scale2x(load(filepath('terrain01.png'))).convert_alpha() _midground = scale2x(load(filepath('mountains00.png'))).convert_alpha() _car0 = scale2x(load(filepath('buggy00.png'))).convert_alpha() _car1 = scale2x(load(filepath('buggy01.png'))).convert_alpha() _car2 = scale2x(load(filepath('buggy02.png'))).convert_alpha() _car3 = scale2x(load(filepath('buggy03.png'))).convert_alpha() allsprites = pygame.sprite.Group() car = Car([_car0, _car1, _car2, _car3], settings.GROUND_HEIGHT, allsprites) bground = pygame.transform.scale(_bground, settings.DISPLAY_SIZE) moonbase = None MAXX, MAXY = settings.DISPLAY_SIZE GHEIGHT = settings.GROUND_HEIGHT _largeterrain = pygame.Surface((MAXX, GHEIGHT)) _largeterrain.set_colorkey(settings.BLACK) _terrains = [_terrain00, _terrain01] width = 0 for i in range(10): _largeterrain.blit(_terrains[0], (width, 0)) width += _terrains[0].get_size()[0] _terrains.reverse() starfield = Background(_starfield, pygame.Rect(0, 0, MAXX, GHEIGHT-10), 0) background = Background(crop(bground, pygame.Rect(0, 0, MAXX, GHEIGHT-100+5)), pygame.Rect(0, 100, MAXX, GHEIGHT-100+5), settings.SCROLL_SPEED) ground = Background(crop(_largeterrain, pygame.Rect(0, 0, MAXX, MAXY-GHEIGHT)), pygame.Rect(0, GHEIGHT, MAXX, MAXY-GHEIGHT), settings.GROUND_SPEED) midground = Background(crop(_midground, pygame.Rect(0, 0, MAXX, GHEIGHT-200+5)), pygame.Rect(0, 200, MAXX, GHEIGHT-200+5), settings.SCROLL_SPEED + 1) clock = pygame.time.Clock() # groups bullets = pygame.sprite.Group() enemies = pygame.sprite.Group() badthings = pygame.sprite.Group() ufos = pygame.sprite.Group() bombs = pygame.sprite.Group() rocks = pygame.sprite.Group() potholes = pygame.sprite.Group() moonbases = pygame.sprite.Group() bgrounds = [starfield, background, midground, ground] _font = pygame.font.Font(filepath('amiga4ever.ttf'), 16) makehud.font = _font gs = GameState() pygame.mixer.music.load(filepath('pink-summertime.mod')) pygame.mixer.music.play(-1) while 1: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() if event.type == pygame.KEYDOWN: if event.key == QUIT or event.key==pygame.K_q: sys.exit() if event.key == SPEEDUP: car.change_speed(1) if event.key == SLOWDOWN: car.change_speed(-1) if event.key == JUMP: car.jump() rect = car.rect Bullet(rect.left+5, rect.top, 0, 10, bullets) Bullet(rect.right-10, rect.centery-5, 10, 0, bullets) if event.key == pygame.K_p: import pdb;pdb.set_trace() clock.tick(60) makeenemy(enemies) if gs.nearmoonbase(): if not moonbase: moonbase = Moonbase(settings.DISPLAY_SIZE[0], moonbases) # only if there is below a certain threshold on screen. badstuff = sum(map(len, [potholes, rocks, bombs])) if badstuff < settings.MAX_BAD_STUFF: makepothole(potholes, badthings) makerock(rocks, badthings) for ufo in enemies: badstuff = sum(map(len, [potholes, rocks, bombs])) if badstuff < settings.MAX_BAD_STUFF: makebomb( ufo.rect.centerx, ufo.rect.bottom, bombs, badthings) # blit first bit. render_star(screen, bgrounds[0]) render_background(screen, bgrounds[1]) render_midground(screen, bgrounds[2]) render_terrain(screen, bgrounds[3]) #[b.render(screen) for b in bgrounds] gs.update();gs.incdist() enemies.update() potholes.update() bombs.update() allsprites.update() bullets.update() rocks.update() moonbases.update() allsprites.draw(screen) enemies.draw(screen) bullets.draw(screen) potholes.draw(screen) bombs.draw(screen) rocks.draw(screen) moonbases.draw(screen) if moonbase: ratio_collide = pygame.sprite.collide_rect_ratio(0.9) if ratio_collide(moonbase, car): gs.atmoonbase = True # check player dead conditions. collided = pygame.sprite.spritecollide(car, badthings, False) if collided: # ok player collided with a bad thing should be dead... but reallyhit = pygame.sprite.spritecollide( car, collided, False, carefulcollide) if reallyhit: potholes.empty() enemies.empty() bullets.empty() bombs.empty() rocks.empty() badthings.empty() car.reset() car._sounds['dead'].play() gs.lives -= 1 gs._distance = 0 # check enemy dead conditions. collided = pygame.sprite.groupcollide( bullets, enemies, True, True) for ufo_colls in collided.values(): for ufo in ufo_colls: ufo._sounds['dead'].play() gs.incpoint() # check for killed bombs. collided = pygame.sprite.groupcollide( bullets, bombs, True, True) for bomb_colls in collided.values(): for bomb in bomb_colls: bomb._sounds['dead'].play() bomb.kill() gs.incpoint() pygame.sprite.groupcollide(potholes, rocks, False, True) # check for killed rocks. collided = pygame.sprite.groupcollide( bullets, rocks, True, True) for rock_colls in collided.values(): for rock in rock_colls: rock._sounds['dead'].play() rock.kill() gs.incpoint() for bomb in bombs: if bomb.rect.bottom - 5 > settings.GROUND_HEIGHT: placepothole(bomb.rect.centerx, potholes, badthings) bomb.kill() bomb._sounds['dead'].play() # HUD display. hud = makehud( time=gs.time, points=gs.points, lives=gs.lives, distance=gs.distance) screen.blit(hud, (100, 500)) pygame.display.flip() if checkendgame(gs): break return gs