Unaligned Bullets

from pygame import *
from pygame.locals import *
from math import *
import sys

global vel
vel = 10 #speed of movement
global FPS
global clock
global time_spent

def RelRect(char, camera):
    return Rect(char.rect.x - camera.rect.x, char.rect.y - camera.rect.y, char.rect.w, char.rect.h)

class Camera(object):
    '''Class for center screen on the player'''
    def __init__(self, screen, player, levelWidth, levelHeight):
        self.player = player
        self.rect = screen.get_rect()
        self.rect.center = self.player.center
        self.worldRect = Rect(0, 0, levelWidth, levelHeight)

    def update(self):
        if self.player.centerx > self.rect.centerx:
            self.rect.centerx = self.player.centerx

        if self.player.centerx < self.rect.centerx:
            self.rect.centerx = self.player.centerx

        if self.player.centery > self.rect.centery:
            self.rect.centery = self.player.centery

        if self.player.centery < self.rect.centery:
            self.rect.centery = self.player.centery


    def draw_sprites(self, surface, sprites):
        for sprite in sprites:
            if sprite.rect.colliderect(self.rect):
                surface.blit(sprite.image, RelRect(sprite, self))


class Obstacle(sprite.Sprite):
    '''Class for create obstacles'''
    def __init__(self, x, y):
        self.x = x
        self.y = y
        sprite.Sprite.__init__(self)
        self.image = image.load("world/obstacle.png").convert()
        self.rect = self.image.get_rect()
        self.rect.topleft = [self.x, self.y]

bullets = []
class Bullet():

    def __init__(self, x, y, targetX, targetY):
        self.image = ''
        self.origX = x
        self.origY = y
        self.x = x
        self.y = y
        self.targetX = targetX
        self.targetY = targetY
        self.image = image.load('res/attack/attack.png')

        self.vel = 20
        # rnge is the range of the bullet, in frames
        self.rnge = 50
        # prog is the progress of the bullet, in frames
        self.prog = 0
        # dmg is the damage that the bullet will do upon impact
        self.dmg = 1
        self.dmg_mult = 1
        # deathtick is the timer for enemy death
        self.deathTick = 0
        # rect is the hitbox of the bullet
        self.w, self.h = self.image.get_width(), self.image.get_height()
        self.rect = Rect(self.x, self.y, self.w, self.h)

    def update(self):
        # Increases Progress of the bullet
        if not (sqrt((self.targetX - self.origX) ** 2 + (self.targetY - self.origY) ** 2)) == 0:

            self.x += int((self.vel) * (self.targetX - self.origX) /
                          (sqrt((self.targetX - self.origX) ** 2 +
                                (self.targetY - self.origY) ** 2)))
            self.y += int((self.vel) * (self.targetY - self.origY) /
                          (sqrt((self.targetX - self.origX) ** 2 +
                                (self.targetY - self.origY) ** 2)))

        self.rect.center = [self.x, self.y]

    def check(self, enemies):
        # Checks if the bullet is out of range, then deletes it, if it is
        if self.prog >= self.rnge:
            bullets.remove(self)
        #checks if bullets are out of bounds
        elif not 0 < self.x < WIDTH - self.w or not 0 < self.y < HEIGHT - self.h:
            bullets.remove(self)

        else:
            #checks if bullet hits target hitbox, if so, starts a timer that kills the bullet after 1 frame
            for e in enemies:
                if self.rect.colliderect(e.hitbox):
                    self.deathTick += 1

            if self.deathTick > 1:
                bullets.remove(self)

    #draws each bullet
    def draw(self):
        screen.blit(self.image, self.rect)

    #draws bullet hitboxes
    def debug(self):
        draw.rect(screen, (0,0,0), self.rect, 2)
        draw.line(screen, (255,255,255), (self.x, self.y), (self.targetX, self.targetY), 4)

class Player(sprite.Sprite):
    '''class for player and collision'''
    def __init__(self, x, y):
        sprite.Sprite.__init__(self)
        self.moveUnitsY = 0
        self.moveUnitsX = 0
        self.x = x
        self.y = y
        self.ground = False
        self.jump = False
        self.image = image.load("res/move/Ridle.png").convert()
        self.rect = self.image.get_rect()

        self.Lrun = ["res/move/L1.png",
                     "res/move/L2.png",
                     "res/move/L3.png",
                     "res/move/L4.png",
                     "res/move/L5.png",
                     "res/move/L6.png"]

        self.Rrun = ["res/move/R1.png",
                     "res/move/R2.png",
                     "res/move/R3.png",
                     "res/move/R4.png",
                     "res/move/R5.png",
                     "res/move/R6.png"]

        self.direction = "right"
        self.rect.topleft = [x, y]
        self.frame = 0

    def update(self, up, down, left, right):
        if up:
            if self.ground:
                if self.direction == "right":
                    self.image = image.load("res/move/Ridle.png")
                self.jump = True
                self.moveUnitsY -= 20
        if down:
            if self.ground and self.direction == "right":
                self.image = image.load("res/move/Ridle.png").convert_alpha()
            if self.ground and self.direction == "left":
                self.image = image.load("res/move/Lidle.png").convert_alpha()

        if not down and self.direction == "right":
                self.image = image.load("res/move/Ridle.png").convert_alpha()

        if not down and self.direction == "left":
            self.image = image.load("res/move/Lidle.png").convert_alpha()

        if left:
            self.direction = "left"
            self.moveUnitsX = -vel
            if self.ground:
                self.frame += 1
                self.image = image.load(self.Lrun[self.frame]).convert_alpha()
                if self.frame == 4: self.frame = 0
            else:
                self.image = self.image = image.load("res/move/Lidle.png").convert_alpha()

        if right:
            self.direction = "right"
            self.moveUnitsX = +vel
            if self.ground:
                self.frame += 1
                self.image = image.load(self.Rrun[self.frame]).convert_alpha()
                if self.frame == 4: self.frame = 0
            else:
                self.image = self.image = image.load("res/move/Ridle.png").convert_alpha()

        if not (left or right):
            self.moveUnitsX = 0
        self.rect.right += self.moveUnitsX

        self.collide(self.moveUnitsX, 0, world)


        if not self.ground:
            self.moveUnitsY += 0.3
            if self.moveUnitsY > 10:
                self.moveUnitsY = 10
            self.rect.top += self.moveUnitsY

        if self.jump:

            self.moveUnitsY += 2
            self.rect.top += self.moveUnitsY
            if self.ground == True:
                self.jump = False

        self.ground = False
        self.collide(0, self.moveUnitsY, world)


    def collide(self, moveUnitsX, moveUnitsY, world):
        self.ground = False
        for pos in world:
            if self.rect.colliderect(pos):
                if moveUnitsX > 0:
                    self.rect.right = pos.rect.left
                if moveUnitsX < 0:
                    self.rect.left = pos.rect.right
                if moveUnitsY > 0:
                    self.rect.bottom = pos.rect.top
                    self.moveUnitsY = 0
                    self.ground = True
                if moveUnitsY < 0:
                    self.rect.top = pos.rect.bottom
                    self.moveUnitsY = 0

class Level(object):
    '''Read a map and create a level'''
    def __init__(self, open_level):
        self.level1 = []
        self.world = []
        self.all_sprite = sprite.Group()
        self.level = open(open_level, "r")

    def create_level(self, x, y):
        for l in self.level:
            self.level1.append(l)

        for row in self.level1:
            for col in row:
                if col == "X":
                    obstacle = Obstacle(x, y)
                    self.world.append(obstacle)
                    self.all_sprite.add(self.world)
                if col == "P":
                    self.player = Player(x,y)
                    self.all_sprite.add(self.player)
                x += 25
            y += 25
            x = 0

    def get_size(self):
        lines = self.level1
        #line = lines[0]
        line = max(lines, key=len)
        self.width = (len(line))*25
        self.height = (len(lines))*25
        return (self.width, self.height)



def sec(time,fps):
    temp = time.tick(fps)
    sec = temp / 1000.
    return sec


init()
WIDTH, HEIGHT = 1000, 700
screen = display.set_mode((WIDTH, HEIGHT))

screen_rect = screen.get_rect()
background = image.load("world/background.png").convert_alpha()
background_rect = background.get_rect()
level = Level("level/level1")
level.create_level(0,0)
world = level.world
player = level.player

camera = Camera(screen, player.rect, level.get_size()[0], level.get_size()[1])
all_sprite = level.all_sprite

FPS = 30
clock = time.Clock()
mx, my = 0, 0
button = 0
up = down = left = right = False
x, y = 0, 0
running = True
enemies = []

while running:
    for evnt in event.get():
        if evnt.type == QUIT or evnt.type == KEYDOWN and evnt.key == K_ESCAPE:
            running = False

        if evnt.type == KEYDOWN and evnt.key == K_UP:
            up = True
        if evnt.type == KEYDOWN and evnt.key == K_DOWN:
            down = True
        if evnt.type == KEYDOWN and evnt.key == K_LEFT:
            left = True
        if evnt.type == KEYDOWN and evnt.key == K_RIGHT:
            right = True

        if evnt .type == MOUSEBUTTONDOWN:
            # checks if any mouse button is down,  if so sets clicking to true
            button = evnt.button
        #startTicks = time.get_ticks()
        if evnt.type == MOUSEBUTTONUP:
            # checks if any mouse button is down,  if so sets clicking to true
            button = 0
        if evnt.type == MOUSEMOTION:
            # sets mx and my to mouse x backgand y if mouse is moving
            mx, my  = evnt.pos

        if evnt.type == KEYUP and evnt.key == K_UP:
            up = False
        if evnt.type == KEYUP and evnt.key == K_DOWN:
            down = False
        if evnt.type == KEYUP and evnt.key == K_LEFT:
            left = False
        if evnt.type == KEYUP and evnt.key == K_RIGHT:
            right = False

    if button == 1:
        bullets.append(Bullet(player.rect[0]+ player.rect[2]//2, player.rect[1] + player.rect[3]//2, mx, my))




    asize = ((screen_rect.w // background_rect.w + 1) * background_rect.w, (screen_rect.h // background_rect.h + 1) * background_rect.h)
    bg = Surface(asize)

    for x in range(0, asize[0], background_rect.w):
        for y in range(0, asize[1], background_rect.h):
            screen.blit(background, (x, y))

    for b in bullets:
        b.update()
        b.draw()
        b.check(enemies)

    time_spent = sec(clock, FPS)
    camera.draw_sprites(screen, all_sprite)

    draw.rect(screen, (255,0,0), player.rect, 4)

    player.update(up, down, left, right)
    camera.update()
    display.flip()