Shooter for PyGame

import sys, pygame, math, random
pygame.init()

width, height = 320, 240
screen = pygame.display.set_mode((width, height))

tick = pygame.time.get_ticks()

class Hitbox:
    'Hitbox used to detect collisions'

    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    def checkPoint(self, x, y):
        return (x > self.x and x < self.x+self.width and y > self.y and y < self.y+self.height);

    def draw(self, col):
        screen.fill(col, pygame.Rect(self.x, self.y, self.width, self.height))

    def check(self, hitbox, n):
        tl = hitbox.checkPoint(self.x, self.y)
        tr = hitbox.checkPoint(self.x+self.width, self.y)
        bl = hitbox.checkPoint(self.x, self.y+self.height)
        br = hitbox.checkPoint(self.x+width, self.y+self.height)
        other = False
        if n != 1:
            other = hitbox.check(self, 1)
        return (tl or tr or bl or br or other)

bullets = []
ents = []
screenBox = Hitbox(0, 0, width, height)

def checkCollision(es):
    collision = False
    for i in range(0, len(bullets)):
        blt = bullets[i]
        col = 0
        for j in range(0, len(es)):
            e = es[j]
            if e != blt and blt != None:
                if e.getHitbox().check(blt.getHitbox(), 0):
                    col = col + 1
        if col == len(es):
            collision = True

    if not collision:
        for i in range(0, len(ents)):
            ent = ents[i]
            col = 0
            for j in range(0, len(es)):
                e = es[j]
                if ent != e and ent != None:
                    if e.getHitbox().check(ent.getHitbox(), 0):
                        col = col + 1
            if col == len(es):
                collision = True

    if not collision:
        if not e.getHitbox().check(screenBox, 1):
            collision = True

    return collision

class Entity:
    'Game-Entity class, used for players'

    def __init__(self, x, y, size, health, col):
        self.x = x
        self.y = y
        self.size = size
        self.dir = [0, 0]
        self.health = health
        self.index = 0
        self.col = col
        self.slow = 1
        self.cticks = pygame.time.get_ticks()
        if col == None:
            self.col = (255, 255, 255)

    def move(self, x, y, cols):
        if pygame.time.get_ticks() - self.cticks > self.slow:
            self.x = self.x+x
            self.y = self.y+y
            collider = [self]
            if cols != None:
                collider = cols
            if checkCollision(collider):
                #print("COLLIDED")
                self.x = self.x-x
                self.y = self.y-y
                return False
            else:
                self.cticks = pygame.time.get_ticks()
        return True

    def update(self, args):

        return;

    def draw(self, col):
        self.getHitbox().draw(col)
        return;

    def getHitbox(self):
        return Hitbox(self.x-(self.size/2), self.y-(self.size/2), self.size/2, self.size/2)

def getPoint(x, y, r, angle):
    px = x + math.sin(angle)*r
    py = y + math.cos(angle)*r
    return px, py;

def getDirection(x1, y1, x2, y2):
    #difx = max(x1, x2) - min(x1, x2)
    #dify = max(y1, y2) - min(y1, y2)
    difx = x1 - x2
    dify = y1 - y2
    angle = math.atan(difx/dify)
    #print("DIR: " + str(difx) + "," + str(dify) + "; " + str(180 * angle / math.pi))
    if dify < 0:
        angle = angle - math.pi
    #if difx >= 0 and dify <= 0:
    #    angle = angle + (math.pi/2)
    #if difx <= 0 and dify <= 0:
    #    angle = angle + (math.pi)
    #if difx <= 0 and dify >= 0:
    #    angle = angle + ((3*math.pi)/2)
    #print("ADIR: " + str(difx) + "," + str(dify) + "; " + str(180 * angle / math.pi))
    angle = angle + math.pi
    return angle

class Bullet(Entity):
    'Game-Bullet class, fired by player'

    def startUp(self, x, y, parent, slow):
        self.dir = [x, y]
        self.slow = slow
        self.index = len(bullets)
        self.parent = parent
        bullets.append(self)

    def update(self, args):
        if not self.move(self.dir[0], self.dir[1], [self, self.parent]):
            #print("BULLET DESTROYED @ " + str(self.x) + "," + str(self.y))
            bullets[self.index] = None
        if not screenBox.checkPoint(self.x, self.y):
            bullets[self.index] = None
        for i in range(0, len(ents)):
            ent = ents[i]
            if ent != self.parent and ent != None:
                if ent.getHitbox().checkPoint(self.x, self.y):
                    ent.health = ent.health - 1
                    bullets[self.index] = None


class Player(Entity):
    'Game-Player class, the player'

    def startUp(self, slow):
        ents.append(self)
        self.index = 0
        self.slow = slow
        self.shootDelay = 500
        self.sticks = pygame.time.get_ticks()

    def shoot(self, x, y):
        if pygame.time.get_ticks()-self.sticks > self.shootDelay:
            self.sticks = pygame.time.get_ticks()
            angle = getDirection(self.x, self.y, x, y)
            dx, dy = getPoint(0, 0, 1, angle)
            #print("DIRECTION:" + str(dx) + "," + str(dy))
            #print("ANGLE:" + str(angle) + "," + str(180 * angle / math.pi))
            blt = Bullet(self.x, self.y, 10, 1, (255, 0, 0))
            blt.startUp(dx, dy, self, 1)

    def update(self, args):
        if self.health <= 0:
            ents[self.index] = None
        self.move(self.dir[0], self.dir[1], None)
        self.dir = [0,0]
        return;

class Enemy(Entity):
    'Game-Enemy class, the enemies)'

    def startUp(self,  slow):
        self.index = len(ents)
        self.slow = slow
        ents.append(self)

    def update(self, args):
        if self.health <= 0:
            ents[self.index] = None
        return;


player = Player(5, 5, 30, 10, (0, 255, 0))
player.startUp(5)
enemy = Enemy(100, 100, 25, 5, (0, 0, 255))
enemy.startUp(25)

def update():
    screen.fill((0, 0, 0))
    for i in range(0, len(bullets)):
        blt = bullets[i]
        if blt != None:
            blt.update([player])
            blt.draw(blt.col)

    for i in range(0, len(ents)):
        ent = ents[i]
        if ent != None:
            ent.update([player])
            ent.draw(ent.col)
    pygame.display.flip()


while 1:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    if pygame.time.get_ticks()-tick > 10:

        prsd = pygame.key.get_pressed()
        if prsd[pygame.K_UP] or prsd[pygame.K_w]:
            player.dir[1] = -1
        if prsd[pygame.K_DOWN] or prsd[pygame.K_s]:
            player.dir[1] = 1
        if prsd[pygame.K_LEFT] or prsd[pygame.K_a]:
            player.dir[0] = -1
        if prsd[pygame.K_RIGHT] or prsd[pygame.K_d]:
            player.dir[0] = 1


        mprsd = pygame.mouse.get_pressed()
        if mprsd[0]:
            xy = pygame.mouse.get_pos()
            #print(str(xy[0]) + ' ' + str(xy[1]))
            player.shoot(xy[0], xy[1])
        if mprsd[1]:
            xy = pygame.mouse.get_pos()
            enemy = Enemy(xy[0], xy[1], 25, 5, (0, 0, 255))
            enemy.startUp(25)


        update()
        tick = pygame.time.get_ticks()