Pygame sprite and group shooting example

import pygame
import random

# This will hold and manage images.
# Because you want to create, load, and/or alter once.
# Rotating can be exception.
class Images:
    def __init__(self):
        self.create()

    def create(self):
        self.player = pygame.Surface((20, 20), pygame.SRCALPHA)
        self.player.fill((0, 0, 0, 0))
        color = pygame.Color("dodgerblue")
        pygame.draw.polygon(self.player, color, ((10, 0), (0, 19), (19, 19)), 1)

        # Bullet on x-axis. Works with vector angle
        # If head is -x. Rotate +y to work with vector angle
        self.bullet = pygame.Surface((6, 2), pygame.SRCALPHA)
        self.bullet.fill(pygame.Color("lawngreen"))

        colors = "orange", "purple", "grey60"
        self.enemies = []
        for color in colors:
            surface = pygame.Surface((10, 10), pygame.SRCALPHA)
            surface.fill(pygame.Color(color))
            self.enemies.append(surface)

class Entity(pygame.sprite.Sprite):
    def __init__(self, image, position, anchor="topleft"):
        # Initialize sprite
        super().__init__()
        # Set image reference
        self.image = image
        # Get rect. **{} just unpack a dict
        self.rect = image.get_rect(**{anchor: position})
        # Use vector2 to hold floats and for built in math
        self.position = pygame.Vector2(self.rect.center)

    def bound_check(self, area):
        pass

    def move(self, x, y):
        self.position += (x, y)
        self.rect.center = self.position

    def move_vector(self, v):
        self.position += v
        self.rect.center = self.position

    def update(self, delta):
        pass

class Player(Entity):
    def __init__(self, image, position, gun):
        super().__init__(image, position, "bottomleft")
        self.velocity = 80
        self.gun = gun

    def bound_check(self, area):
        clamp = self.rect.clamp(area)
        if self.rect.x != clamp.x or self.rect.y != clamp.y:
            self.rect = clamp
            self.position = pygame.Vector2(self.rect.center)

    def update(self, delta):
        self.gun.update(delta)
        key_state = pygame.key.get_pressed()
        mouse_state = pygame.mouse.get_pressed()
        x = 0
        if key_state[pygame.K_LEFT] or key_state[pygame.K_a]:
            x = -1
        elif key_state[pygame.K_RIGHT] or key_state[pygame.K_d]:
            x = 1

        if key_state[pygame.K_SPACE] or mouse_state[0]:
            self.gun.fire(self)

        if x != 0:
            x *= self.velocity * delta
            self.move(x, 0)

class Gun:
    def __init__(self, image, groups, velocity, fire_rate):
        self.ticks = 0
        self.image = image
        self.groups = groups
        self.velocity = velocity
        self.fire_rate = fire_rate

    def fire(self, entity):
        if self.ticks == 0:
            mpos = pygame.Vector2(pygame.mouse.get_pos())
            vector = (mpos - entity.position).normalize()
            position = entity.position + vector * entity.rect.width / 2
            bullet = Bullet(self.image, 180, vector, position)
            bullet.add(self.groups)
            self.ticks = self.fire_rate

    def update(self, delta):
        if self.ticks > 0:
            self.ticks -= delta
            if self.ticks < 0:
                self.ticks = 0

class Bullet(Entity):
    def __init__(self, image, velocity, vector, position):
        angle = vector.as_polar()[1]
        image = pygame.transform.rotate(image, -angle)
        super().__init__(image, position, "center")
        self.velocity = velocity
        self.vector = vector

    def bound_check(self, area):
        if not self.rect.colliderect(area):
            self.kill()

    def update(self, delta):
        self.move_vector(self.vector * self.velocity * delta)

class Game:
    def __init__(self, caption, width, height, flags=0):
        pygame.display.set_caption(caption)
        self.surface = pygame.display.set_mode((width, height), flags)
        self.rect = self.surface.get_rect()
        self.clock = pygame.time.Clock()
        self.running = False
        self.delta = 0
        self.fps = 0

        self.images = Images()
        self.background = pygame.Color("black")

        self.sprites = pygame.sprite.Group()
        self.enemies = pygame.sprite.Group()
        self.bullets = pygame.sprite.Group()
        # Player
        gun = Gun(self.images.bullet, (self.sprites, self.bullets), 180, .3)
        position = self.rect.centerx, self.rect.bottom - 20
        self.player = Player(self.images.player, position, gun)
        self.sprites.add(self.player)
        # Enemies
        for x in range(50, self.rect.width, 50):
            for y in range(40, self.rect.height - 100, 50):
                image = random.choice(self.images.enemies)
                enemy = Entity(image, (x, y), "center")
                enemy.add(self.sprites, self.enemies)

    def draw(self):
        self.surface.fill(self.background)
        self.sprites.draw(self.surface)

    def mainloop(self):
        self.running = True
        while self.running:
            # Event loop
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False

            self.update()
            self.draw()
            pygame.display.flip()
            # Delta time for smooth movement
            self.delta = self.clock.tick(self.fps) * 0.001

    def update(self):
        self.sprites.update(self.delta)
        self.player.bound_check(self.rect)
        for bullet in self.bullets:
            bullet.bound_check(self.rect)

        collision = pygame.sprite.groupcollide(self.bullets, self.enemies, True, True)

if __name__ == "__main__":
    pygame.init()
    game = Game("Shoot Them", 800, 600)
    game.mainloop()
    pygame.quit()