Exemple #1
0
    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)
Exemple #2
0
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 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))
Exemple #4
0
    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
Exemple #5
0
    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)
Exemple #6
0
    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
Exemple #8
0
 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()
Exemple #9
0
    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
Exemple #10
0
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)
Exemple #11
0
 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]
Exemple #12
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 = []
Exemple #13
0
    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)
Exemple #14
0
    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()
Exemple #16
0
    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())
Exemple #17
0
    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'))}
Exemple #18
0
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)
Exemple #19
0
    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'))
        }
Exemple #20
0
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)
Exemple #21
0
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
Exemple #22
0
# 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]
Exemple #23
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
Exemple #24
0
def update_display_scaled2x(dirty):
    scale2x(screen, screen_surface)
    flip()
 def apply_scaling(image):
     return pytf.scale2x(image)
Exemple #26
0
def update_display_scaled2x(dirty):
    scale2x(screen, screen_surface)
    flip()
Exemple #27
0
def scale(surface: Surface) -> Surface:
    from pygame.transform import scale2x
    return scale2x(scale2x(surface))
Exemple #28
0
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
Exemple #29
0
# 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()
Exemple #30
0
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