4 files

#game.py


import pygame
from pygame.color import *
from player import *
from pygame.event import *

settings = [pygame.K_a,pygame.K_d,pygame.K_w,pygame.K_s,pygame.K_SPACE]

left_key = settings[0]
right_key = settings[1]
up_key = settings[2]
down_key = settings[3]
shoot_key = settings[4]

class game:
    def render(self):
        return
    def update(self):
        return
    def handle_events(self, event):
        keys = pygame.key.get_pressed()
        if event.type == pygame.KEYDOWN: #if key pressed
            if keys[shoot_key]:
                self.player.shoot()

        return

class ShootThings(game):

    def __init__(self):
        self.screen = pygame.display.get_surface()
        self.player = player()
        return

    def render(self):
        draw_entity(self.screen,self.player)
        self.player.draw(self.screen)
        return

    def update(self, dt):
        keys = pygame.key.get_pressed()

        self.player.update(dt)

        if keys[left_key]:
            self.player.position.x -= dt*self.player.speed
        elif keys[right_key]:
            self.player.position.x += dt*self.player.speed
        if keys[up_key]:
            self.player.position.y -= dt*self.player.speed
        elif keys[down_key]:
            self.player.position.y += dt*self.player.speed

        return

#main.py

import pygame,sys,os
from pygame.event import *
from pygame.locals import *
from pygame.draw import *

from game import *
from player import *


def main():
    pygame.init()
    pygame.display.set_mode((640,480))

    running = 0

    game = ShootThings()

    gameclock = pygame.time.Clock()


    while running==0:
        pygame.display.set_caption(str(gameclock.get_fps()))
        events = pygame.event.get()
        for event in events:
            if event.type == QUIT:
                running = 1
            else:
                game.handle_events(event)
        pygame.draw.rect(pygame.display.get_surface(),Color(0,0,0),(0,0,640,480))
        game.render()
        game.update(gameclock.get_time())
        pygame.display.flip()
        gameclock.tick()


    return


main()

#vec2.py

import math

class vec2:
    def __init__(self,x = 0.0, y = 0.0):
        self.x = x
        self.y = y

    def __iadd__(self,other):
        if not isinstance(other,self.__class__):
            return NotImplemented
        self.x += other.x
        self.y += other.y

    def __add__(self,other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        result = self.__class__(self.x, self.y)
        result.x += other.x
        result.y += other.y
        return result

    def __sub__(self,other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        result = self.__class__(self.x, self.y)
        result.x -= other.x
        result.y -= other.y
        return result

    def __mul__(self,scalar):
        if not isinstance(scalar, self.__class__):
            return NotImplemented
        result = self.__class__(self.x, self.y)
        result.x *= scalar.x
        result.y *= scalar.y
        return result

    def length(self):
        return math.sqrt(self.x*self.x + self.y*self.y)


#player.py


from vec2 import vec2
import pygame.draw
from pygame.color import *
from pygame.time import *

def draw_entity(screen, ent):
    pygame.draw.rect(screen, ent.color, (ent.position.x,ent.position.y, ent.size.x,ent.size.y))
    return

class entity:
    def __init__(self):
        self.position = vec2()
        self.size = vec2()
        self.color = Color(255,255,255)
        self.velocity = vec2()

    def get_rect(self):
        return pygame.Rect(self.position.x,self.position.y,self.size.x,self.size.y)

class particle(pygame.sprite.DirtySprite,entity):

    def __init__(self,position,velocity):
        pygame.sprite.DirtySprite.__init__(self)
        entity.__init__(self)
        self.position = position
        self.velocity = velocity

    def update(self,dt):
        self.position += self.velocity * dt



class player(entity):
    speed = 0.1
    shoot_timer = Clock()
    elapsed_time = 0
    shoot_speed = 500
    particlegroup = pygame.sprite.Group()
    particles = []

    def __init__(self):
        entity.__init__(self)
        self.size.x = 15.0
        self.size.y = 15.0
        self.position.x = 320.0-self.size.x/2.0
        self.position.y = 240.0-self.size.y

    def draw(self,screen):
        pygame.draw.rect(screen,Color(255,255,255),(self.position.x,self.position.y,self.size.x,self.size.y))

    def shoot(self):
        if(self.elapsed_time > self.shoot_speed):
            self.particles.append(particle((self.position),(0.0,-1.0)))
            self.elapsed_time = 0

    def update(self, dt):
        self.shoot_timer.tick()

        self.elapsed_time += dt

        for p in self.particles:
            p.update(dt)