collision.py

import sys
import random
import pygame as pg


CAPTION = "Collisions"
SCREEN_SIZE = (500, 500)
BACKGROUND_COLOR = (30, 20, 30)


DIRECT_DICT = {pg.K_LEFT  : (-1, 0),
               pg.K_RIGHT : ( 1, 0),
               pg.K_UP    : ( 0,-1),
               pg.K_DOWN  : ( 0, 1)}


class _Block(pg.sprite.Sprite):
    def __init__(self, pos, size, color, *groups):
        pg.sprite.Sprite.__init__(self, *groups)
        self.rect = pg.Rect(pos, size)
        self.image = pg.Surface(size).convert()
        self.image.fill(color)

    def draw(self, surface):
        surface.blit(self.image, self.rect)


class Obstacle(_Block):
    SIZE = (50, 50)
    
    def __init__(self, pos, *groups):
        color = random.choice(list(pg.color.THECOLORS.values()))
        _Block.__init__(self, pos, Obstacle.SIZE, color, *groups)
        
    
class Player(_Block):
    SIZE = (20, 20)
    COLOR = pg.Color("tomato")
    
    def __init__(self, pos, *groups):
        _Block.__init__(self, pos, Player.SIZE, Player.COLOR, *groups)
        self.speed = 3

    def update(self, obstacles):
        """Updates our player appropriately every frame."""
        vector = [0, 0]
        keys = pg.key.get_pressed()
        for key in DIRECT_DICT:
            if keys[key]:
                vector[0] += DIRECT_DICT[key][0]
                vector[1] += DIRECT_DICT[key][1]
        self.movement(obstacles, vector)

    def movement(self, obstacles, vector):
        for i, val in enumerate(vector):
            self.rect[i] += val*self.speed
            collision = pg.sprite.spritecollideany(self, obstacles)
            while collision:
                self.adjust_on_collision(collision, i)
                collision = pg.sprite.spritecollideany(self, obstacles)
    
    def adjust_on_collision(self, collide, i):
        """Adjust player's position if colliding with a solid block."""
        if self.rect[i] < collide.rect[i]:
            self.rect[i] = collide.rect[i]-self.rect.size[i]
        else:
            self.rect[i] = collide.rect[i]+collide.rect.size[i]


class App(object):
    def __init__(self):
        self.screen = pg.display.get_surface()
        self.screen_rect = self.screen.get_rect()
        self.clock = pg.time.Clock()
        self.fps = 60
        self.done = False
        self.player = Player((0,0))
        self.player.rect.center = self.screen_rect.center
        self.obstacles = self.make_obstacles()

    def make_obstacles(self):
        """Prepare some obstacles for our player to collide with."""
        group = pg.sprite.Group()
        Obstacle((400,400), group)
        Obstacle((300,270), group)
        Obstacle((150,170), group)
        for i in range(9):
            Obstacle((i*50,0), group)
            Obstacle((450,50*i), group)
            Obstacle((50+i*50,450), group)
            Obstacle((0,50+50*i), group)
        return group

    def event_loop(self):
        for event in pg.event.get():
            if event.type == pg.QUIT:
                self.done = True

    def display_fps(self):
        """Show the program's FPS in the window handle."""
        caption = "{} - FPS: {:.2f}".format(CAPTION, self.clock.get_fps())
        pg.display.set_caption(caption)

    def render(self):
        self.screen.fill(BACKGROUND_COLOR)
        self.obstacles.draw(self.screen)
        self.player.draw(self.screen)
        pg.display.update()
        
    def main_loop(self):
        while not self.done:
            self.event_loop()
            self.player.update(self.obstacles)
            self.render()
            self.clock.tick(self.fps)
            self.display_fps()


def main():
    pg.init()
    pg.display.set_caption(CAPTION)
    pg.display.set_mode(SCREEN_SIZE)
    App().main_loop()
    pg.quit()
    sys.exit()


if __name__ == "__main__":
    main()