from livewires import games
from livewires import colour
import math
import random
SCREENWIDTH = 1000
SCREENHEIGHT = 700
CENTRE_X = SCREENWIDTH / 2
CENTRE_Y = SCREENHEIGHT / 2
class Hittable:
    def check_for_hits(self):
        for i in self.overlapping_objects():
            self.hit(i)
def check_play_again(screen):
    if screen.is_pressed (games.K_1) == True:
        my_screen.clear()
        my_planet = Planet (screen = my_screen)
        FuelBar.num_bars = 0
        my_ship1 = Ship (screen = my_screen, x = SCREENWIDTH/6, y = CENTRE_Y,
                         colour = colour.red, key_left = games.K_a,
                         key_right = games.K_d, key_thrust = games.K_w,
                         key_fire = games.K_t, key_fire_missile = games.K_y,
                         key_drop_mine = games.K_u, key_fire_bomb = games.K_i,
                         ship = 1, lives = 5)
        my_ship2 = Ship (screen = my_screen, x = SCREENWIDTH/1.2, y = CENTRE_Y,
                         colour = colour.green, key_left = games.K_LEFT,
                         key_right = games.K_RIGHT, key_thrust = games.K_UP,
                         key_fire = games.K_KP1, key_fire_missile = games.K_KP2,
                         key_drop_mine = games.K_KP3, key_fire_bomb = games.K_KP4,
                         ship = 2, lives = 5)
        my_ship1 = 5
        my_ship2 = 5
    if screen.is_pressed (games.K_2) == True:
        screen.quit()
class FeelsGravity:
    STRENGTH = 100

    def gravitate (self):
        (x,y) = self.pos ()
        dist_x = CENTRE_X - x
        dist_y = CENTRE_Y - y
        dist_cubed = math.sqrt (dist_x * dist_x + dist_y * dist_y) ** 3
        strength = FeelsGravity.STRENGTH / dist_cubed
        a = (dist_x * strength, dist_y * strength)
        v = self.get_velocity ()
        v = add_vectors (v, a)
        self.set_velocity (v)
    def gravitate_less (self):
        (x,y) = self.pos ()
        dist_x = CENTRE_X - x
        dist_y = CENTRE_Y - y
        dist_cubed = math.sqrt (dist_x * dist_x + dist_y * dist_y) ** 3
        strength = (FeelsGravity.STRENGTH/20) / dist_cubed
        a = (dist_x * strength, dist_y * strength)
        v = self.get_velocity ()
        v = add_vectors (v, a)
        self.set_velocity (v)

class FuelSupply (games.Polygon, games.Mover, FeelsGravity, Hittable):
    TIME_TO_LIVE = 750
    LIST_POINTS = ( (0,0),(18,0),(18,18),(0,18),(0,0) )
    def __init__(self,screen,rx,ry):
        self.screen = screen
        self.init_polygon(screen = self.screen, x = rx, y = ry,
                              shape = FuelSupply.LIST_POINTS, colour = colour.white)
        self.time_left = FuelSupply.TIME_TO_LIVE
        self.init_mover(dx = 0, dy = 0)
    def moved(self):
        self.check_for_hits()
        self.gravitate_less()
        self.time_left -= 1
        if self.time_left < 0:
            self.destroy()
    def hit(self, what_hit_me):
        self.destroy()
class MineUpgrade (games.Polygon, games.Mover, FeelsGravity, Hittable):
    TIME_TO_LIVE = 750
    LIST_POINTS = ( (0,0),(18,0),(18,18),(0,18),(0,0) )
    def __init__(self,screen,rx,ry):
        self.screen = screen
        self.init_polygon(screen = self.screen, x = rx, y = ry,
                          shape = FuelSupply.LIST_POINTS, colour = colour.blue)
        self.time_left = MineUpgrade.TIME_TO_LIVE
        self.init_mover(dx = 0, dy = 0)
    def moved(self):
        self.check_for_hits()
        self.gravitate_less()
        self.time_left -= 1
        if self.time_left < 0:
            self.destroy()
    def hit(self, what_hit_me):
        self.destroy()    
class MissileUpgrade (games.Polygon, games.Mover, FeelsGravity, Hittable):
    TIME_TO_LIVE = 750
    LIST_POINTS = ( (0,0),(18,0),(18,18),(0,18),(0,0) )
    def __init__(self,screen,rx,ry):
        self.screen = screen
        self.init_polygon(screen = self.screen, x = rx, y = ry,
                          shape = FuelSupply.LIST_POINTS, colour = colour.pink)
        self.time_left = MissileUpgrade.TIME_TO_LIVE
        self.init_mover(dx = 0, dy = 0)
    def moved(self):
        self.check_for_hits()
        self.gravitate_less()
        self.time_left -= 1
        if self.time_left < 0:
            self.destroy()
    def hit(self, what_hit_me):
        self.destroy()
class BulletUpgrade (games.Polygon, games.Mover, FeelsGravity, Hittable):
    TIME_TO_LIVE = 750
    LIST_POINTS = ( (0,0),(18,0),(18,18),(0,18),(0,0) )
    def __init__(self,screen,rx,ry):
        self.screen = screen
        self.init_polygon(screen = self.screen, x = rx, y = ry,
                          shape = FuelSupply.LIST_POINTS, colour = colour.brown)
        self.time_left = BulletUpgrade.TIME_TO_LIVE
        self.init_mover(dx = 0, dy = 0)
    def moved(self):
        self.check_for_hits()
        self.gravitate_less()
        self.time_left -= 1
        if self.time_left < 0:
            self.destroy()
    def hit(self, what_hit_me):
        self.destroy()
class BombUpgrade (games.Polygon, games.Mover, FeelsGravity, Hittable):
    TIME_TO_LIVE = 750
    LIST_POINTS = ( (0,0),(18,0),(18,18),(0,18),(0,0) )
    def __init__(self,screen,rx,ry):
        self.screen = screen
        self.init_polygon(screen = self.screen, x = rx, y = ry,
                          shape = FuelSupply.LIST_POINTS, colour = colour.purple)
        self.time_left = BombUpgrade.TIME_TO_LIVE
        self.init_mover(dx = 0, dy = 0)
    def moved(self):
        self.check_for_hits()
        self.gravitate_less()
        self.time_left -= 1
        if self.time_left < 0:
            self.destroy()
    def hit(self, what_hit_me):
        self.destroy()
class Planet (games.Circle,games.Mover, Hittable, FuelSupply):
    RADIUS = 75
    AREA = 7853.9816

    def __init__ (self, screen):
        player1_pos = (0,0)
        player2_pos = (0,0)
        self.init_circle (screen = screen, x = CENTRE_X, y = CENTRE_Y,
                          radius = Planet.RADIUS, colour = colour.purple)
        self.init_mover(dx = 0, dy = 0)
        self.screen = screen
        self.gen_up = 20
    def moved (self):
        check_play_again(screen = self.screen)
        if self.gen_up == 0:
            rnum = random.randint(0, 500)
            if rnum == 500:
                rx = random.randint(0, SCREENWIDTH)
                ry = random.randint(0, SCREENHEIGHT)
                fuelsupply = FuelSupply(screen = self.screen, rx = rx, ry = ry)
            if rnum == 499:
                rx = random.randint(0, SCREENWIDTH)
                ry = random.randint(0, SCREENHEIGHT)
                mineupgrade = MineUpgrade(screen = self.screen, rx = rx, ry = ry)
            if rnum == 498:
                rx = random.randint(0, SCREENWIDTH)
                ry = random.randint(0, SCREENHEIGHT)
                missileupgrade = MissileUpgrade(screen = self.screen, rx = rx, ry = ry)
            if rnum == 497:
                rx = random.randint(0, SCREENWIDTH)
                ry = random.randint(0, SCREENHEIGHT)
                bulletupgrade = BulletUpgrade(screen = self.screen, rx = rx, ry = ry)
            if rnum == 496:
                rx = random.randint(0, SCREENWIDTH)
                ry = random.randint(0, SCREENHEIGHT)
                bombupgrade = BombUpgrade(screen = self.screen, rx = rx, ry = ry)
                self.gen_up = 10
        else:
            self.gen_up -= 1
    def hit (self, what_hit_me):
        fuelsupply.check_for_hits()
def add_vectors (first, second):
    x = first [0] + second [0]
    y = first [1] + second [1]
    return (x,y)


class KeeptoScreen:
    def left_screen (self):
        oldpos = (x,y) = self.pos ()
        if x < 0 or x > SCREENWIDTH or y < 0 or y > SCREENHEIGHT:
            return true
            
    def keep_to_screen (self):

        oldpos = (x,y) = self.pos ()
        if x < 0:
            x = SCREENWIDTH
        if x > SCREENWIDTH:
            x = 0
        if y < 0 + 9:
            y = SCREENHEIGHT
        if y > SCREENHEIGHT :
            y = 0 + 9 
        if (x,y) != oldpos:
            self.move_to ((x,y))
            self.set_velocity([0,0])
    def keep_to_screen_with_speed (self):
        oldpos = (x,y) = self.pos ()
        if x < 0:
            x = SCREENWIDTH
        if x > SCREENWIDTH:
            x = 0
        if y < 0 + 9:
            y = SCREENHEIGHT
        if y > SCREENHEIGHT:
            y = 0 + 9
        if (x,y) != oldpos:
            self.move_to ((x,y))

def angle_and_length (angle, length):
    radian_angle = angle * math.pi / 180
    x = -(length * math.sin (radian_angle))
    y = length * math.cos (radian_angle)
    return (x, y)

class Explode (games.Circle, games.Mover,Hittable, KeeptoScreen):
    TIME_TO_LIVE = 100
    def __init__ (self, screen, object_pos, obj_velocity, size,double_explosive):
        (start_x,start_y) = object_pos
        (start_vx, start_vy) = obj_velocity
        self.init_circle(screen = screen, x = start_x, y = start_y,
                         radius = size, colour = colour.red)
        self.init_mover(dx = start_vx, dy = start_vy)
        self.time_left = Explode.TIME_TO_LIVE
        self.size = size
        self.max_radius = self.size*5
        if double_explosive == True:
            self.max_radius = self.max_radius*2
    def moved(self):
        self.check_for_hits()
        self.new_radius = self.size + Explode.TIME_TO_LIVE/2 - self.time_left/2 
        self.set_radius(self.new_radius) 
        if self.left_screen == True or self.time_left < 0 or self.new_radius > self.max_radius:
            self.destroy()
        self.time_left = self.time_left - 1
    def hit(self, what_hit_me):
        pass

class Fragment(games.Polygon, games.Mover, KeeptoScreen, Hittable, FeelsGravity):
    TIME_TO_LIVE = 40
    SIZE = 2.3
    LIST_POINTS = ((0,0),(0,-3),(-3,-3),(0,3),(3,-3),(0,-3),(0,0))
    def __init__(self, screen, obj_pos, obj_velocity, obj_angle):
        (start_x,start_y) = obj_pos
        (start_vx, start_vy) = obj_velocity
        self.init_polygon(screen = screen, x = start_x, y = start_y,
                         shape = Fragment.LIST_POINTS, colour = colour.yellow)
        self.init_mover(dx = start_vx, dy = start_vy, da = 1)
        self.time_left = Fragment.TIME_TO_LIVE
        self.size = Fragment.SIZE
    def moved(self):
        self.check_for_hits()
        self.gravitate()
        if self.left_screen == True or self.time_left < 0:
            self.destroy()
            explode = Explode(screen = self.screen, object_pos = self.pos (),
                              obj_velocity = self.get_velocity(), size = Fragment.SIZE,
                              double_explosive = False)
        self.time_left = self.time_left - 1
    def hit (self, what_hit_me):
        explode = Explode(screen = self.screen, object_pos = self.pos (),
                          obj_velocity = self.get_velocity(), size = Fragment.SIZE,
                          double_explosive = False)
        self.destroy ()


class Bullet (games.Circle, games.Mover, FeelsGravity, KeeptoScreen, Hittable): 
    SPEED = 5
    TIME_TO_LIVE = 50
    SIZE = 3
    def __init__ (self, screen, ship_pos, ship_velocity, ship_angle):
        offset = Bullet.SIZE + 30
        offset_vec = angle_and_length (ship_angle, offset)
        (start_x, start_y) = add_vectors (ship_pos, offset_vec)
        bullet_velocity = angle_and_length (ship_angle, Bullet.SPEED)
        (start_vx, start_vy) = bullet_velocity
        self.init_circle(screen = screen, x = start_x, y = start_y,
                         radius = Bullet.SIZE, colour = colour.yellow)
        self.init_mover (dx = start_vx, dy = start_vy)
        self.time_left = Bullet.TIME_TO_LIVE
    def moved (self):
        self.check_for_hits()
        self.gravitate()
        if self.left_screen == True or self.time_left < 0:
            self.destroy()
        self.time_left = self.time_left - 1
    def hit (self, what_hit_me):
        if isinstance(what_hit_me, FuelBar) != True:
            self.destroy ()

class Missile (games.Polygon, games.Mover, FeelsGravity, KeeptoScreen, Hittable):
    SPEED = 4
    TIME_TO_LIVE = 125
    SIZE = 4
    LIST_POINTS = ( (0,0),(6,-3),(0,14),(-6,-3),(0,0))
    def __init__ (self, screen, ship_pos, ship_velocity, ship_angle, activate_upgrade, ship):
        offset = Missile.SIZE + 30
        offset_vec = angle_and_length (ship_angle, offset)
        (start_x, start_y) = add_vectors (ship_pos, offset_vec)
        bullet_velocity = angle_and_length (ship_angle, Missile.SPEED)
        (start_vx, start_vy) = bullet_velocity
        self.init_polygon(screen = screen, x = start_x, y = start_y,
                         shape = Missile.LIST_POINTS, colour = colour.yellow)
        self.init_mover (dx = start_vx, dy = start_vy)
        self.activate_homing_missile = activate_upgrade
        self.ship = ship
        self.time_left = Missile.TIME_TO_LIVE
        self.rotate_to(ship_angle)
    def homing_upgrade(self):
        (x,y) = self.pos ()
        if self.ship == 1:
            (op_x,op_y) = Planet.player2_pos
        if self.ship == 2:
            (op_x,op_y) = Planet.player1_pos
        dist_x = op_x - x
        dist_y = op_y - y
        new_angle = math.atan(dist_x/dist_y)
        new_angle = math.degrees(new_angle)
        if dist_y < 0:
            if dist_x < 0:
                new_angle = new_angle - 180
            else:
                new_angle = new_angle + 180
        self.rotate_to(-new_angle)
        change_in_v = angle_and_length (-new_angle, Missile.SPEED*0.075)
        v = self.get_velocity ()
        new_v = add_vectors (v, change_in_v)
        (vx,vy) = new_v
        vx = vx/1.075
        vy = vy/1.075
        new_v = (vx,vy)
        self.set_velocity (new_v)
    def moved (self):
        self.keep_to_screen_with_speed()
        if self.activate_homing_missile == True and self.time_left < 70:
            self.homing_upgrade()
        self.check_for_hits()
        self.gravitate()
        if self.time_left < 0:
            self.destroy()
        self.time_left = self.time_left - 1
    def hit (self, what_hit_me):
        if isinstance(what_hit_me, FuelBar) != True:
            self.destroy ()
class Bomb (games.Polygon, games.Mover, FeelsGravity, KeeptoScreen, Hittable):
    SPEED = 2
    TIME_TO_LIVE = 120
    SIZE = 5
    FRAGMENT_SPEED = 2
    LIST_POINTS = ( (0,0),(3,0),(3,3),(-3,3),(-3,-3),(3,-3),(3,0))
    def __init__ (self, screen, ship_pos, ship_velocity, ship_angle, activate_upgrade):
        offset = Bomb.SIZE + 30
        offset_vec = angle_and_length (ship_angle, offset)
        (start_x, start_y) = add_vectors (ship_pos, offset_vec)
        bullet_velocity = angle_and_length (ship_angle, Bomb.SPEED)
        (start_vx, start_vy) = bullet_velocity
        self.init_polygon(screen = screen, x = start_x, y = start_y,
                         shape = Bomb.LIST_POINTS, colour = colour.yellow)
        self.init_mover (dx = start_vx, dy = start_vy, da = 1)
        self.time_left = Bomb.TIME_TO_LIVE
        self.activate_fragmenting_projectile = activate_upgrade
        self.screen = screen
    def moved (self):
        self.check_for_hits()
        self.gravitate()
        if self.activate_fragmenting_projectile == True and self.time_left < 40:
            rx1 = random.uniform(-Bomb.FRAGMENT_SPEED, Bomb.FRAGMENT_SPEED)
            ry1 = random.uniform(-Bomb.FRAGMENT_SPEED, Bomb.FRAGMENT_SPEED)
            rx2 = random.uniform(-Bomb.FRAGMENT_SPEED, Bomb.FRAGMENT_SPEED)
            ry2 = random.uniform(-Bomb.FRAGMENT_SPEED, Bomb.FRAGMENT_SPEED)
            rx3 = Bomb.FRAGMENT_SPEED - rx1 - rx2
            ry3 = Bomb.FRAGMENT_SPEED - ry1 - ry2
            (rx1,ry1) = add_vectors ((rx1, ry1), self.get_velocity())
            (rx2,ry2) = add_vectors ((rx2, ry2), self.get_velocity())
            (rx3,ry3) = add_vectors ((rx3, ry3), self.get_velocity())
            v1 =(rx1/2,ry1/2)
            v2 = (rx2/2,ry2/2)
            v3 = (rx3/2,ry3/2)
            (x,y) = self.pos()
            pos1 = (x+rx1*5,y+ry1*5)
            pos2 = (x+rx2*5,y+ry2*5)
            pos3 = (x+rx3*5,y+ry3*5)
            fragment = Fragment(screen = self.screen, obj_pos = pos1,
                                obj_velocity = v1, obj_angle = self.angle())
            fragment = Fragment(screen = self.screen, obj_pos = pos2,
                                obj_velocity = v2, obj_angle = self.angle())
            fragment = Fragment(screen = self.screen, obj_pos = pos3,
                                obj_velocity = v3, obj_angle = self.angle())
            self.destroy()
        elif self.left_screen == True or self.time_left < 0:
            explode = Explode(screen = self.screen, object_pos = self.pos (),
                              obj_velocity = self.get_velocity(), size = Bomb.SIZE,
                              double_explosive = False)
            self.destroy()
        self.time_left = self.time_left - 1
    def hit (self, what_hit_me):
        if isinstance(what_hit_me, FuelBar) != True:
            explode = Explode(screen = self.screen, object_pos = self.pos (),
                              obj_velocity = self.get_velocity(), size = Bomb.SIZE,
                              double_explosive = False)
            self.destroy ()

class Mine (games.Circle, games.Mover, FeelsGravity, KeeptoScreen, Hittable, Explode): 
    SPEED = 0.01
    TIME_TO_LIVE = 300
    SIZE = 9
    MAX_V = 0.1
    def __init__ (self, screen, ship_pos, ship_velocity, ship_angle, activate_upgrade):
        offset = Mine.SIZE - 30
        offset_vec = angle_and_length (ship_angle, offset)
        (start_x, start_y) = add_vectors (ship_pos, offset_vec)
        mine_velocity = angle_and_length (ship_angle, Mine.SPEED)
        (start_vx, start_vy) = mine_velocity
        self.init_circle(screen = screen, x = start_x, y = start_y,
                         radius = Mine.SIZE, colour = colour.yellow)
        self.init_mover (dx = -start_vx,
                         dy = -start_vy)
        self.time_left = Mine.TIME_TO_LIVE
        self.screen = screen
        self.activate_double_explosive = activate_upgrade
    def check_for_max_v(self):
        (x,y) = self.get_velocity()
        if x>Mine.MAX_V or y>Mine.MAX_V or x<-Mine.MAX_V or y<-Mine.MAX_V:
            return True
    def moved (self):
        self.check_for_hits()
        self.gravitate_less()
        if self.left_screen == True or self.time_left < 0:
            explode = Explode(screen = self.screen, object_pos = self.pos (),
                          obj_velocity = self.get_velocity(), size = Mine.SIZE,
                          double_explosive = self.activate_double_explosive)
            self.destroy()
        self.time_left = self.time_left - 1
    def hit (self, what_hit_me):
        if isinstance(what_hit_me, FuelBar) != True:
            explode = Explode(screen = self.screen, object_pos = self.pos (),
                              obj_velocity = self.get_velocity(), size = Mine.SIZE,
                              double_explosive = self.activate_double_explosive)
            self.destroy ()


class FuelBar (games.Polygon):
    THICKNESS = 6
    INIT_POINTS = ((0,0),(SCREENWIDTH,0),(SCREENWIDTH,THICKNESS),
                   (0,THICKNESS),(0,0))
    num_bars = 0
    def __init__ (self, screen, start_fuel, colour):
        self.conversion_factor = float (SCREENWIDTH)/start_fuel
        y_pos = FuelBar.num_bars * FuelBar.THICKNESS + 1
        FuelBar.num_bars = FuelBar.num_bars + 1
        self.init_polygon (screen=screen, x = 0, y=y_pos, shape = FuelBar.INIT_POINTS,
                           colour = colour)
    def update (self, fuel_level):
        length = self.conversion_factor * fuel_level
        new_shape = ((0,0),(length,0),(length,FuelBar.THICKNESS),
                     (0,FuelBar.THICKNESS),(0,0))
        self.set_shape (new_shape)


class Ship (games.Polygon, games.Mover, FeelsGravity, KeeptoScreen, Bullet, Hittable, FuelBar, Missile, FuelSupply, Mine, Bomb):
    LIST_POINTS = ( (0,0),(0,-10),(10,-10),(0,20),(-10,-10),(0,-10),(0,0) )
    MAX_V = 3.5
    MAX_FUEL = 500
    THRUST = 0.1
    START_FUEL = 500
    def __init__ (self, screen, x, y, colour, key_left, key_right, key_thrust,key_fire, key_fire_missile, key_drop_mine, key_fire_bomb, ship, lives):
        self.init_polygon (screen = screen, x = x, y = y,
                           shape = Ship.LIST_POINTS, colour = colour)
        self.init_mover (0,0.5,0)
        self.key_left = key_left
        self.key_right = key_right
        self.key_thrust = key_thrust
        self.key_fire = key_fire
        self.key_fire_missile = key_fire_missile
        self.key_drop_mine = key_drop_mine
        self.key_fire_bomb = key_fire_bomb
        Ship.game_over = 0
        self.colour = colour
        self.x = x
        self.y = y
        self.bullet_rof = 20
        self.missile_rof = 40
        self.mine_rof = 100
        self.bomb_rof = 100
        self.fuel_left = Ship.START_FUEL
        self.live = lives
        self.ship = ship
        self.quick_turn_left = 0
        self.quick_turn_right = 0
        self.activate_Mine_upgrade = False
        self.activate_Missile_upgrade = False
        self.activate_Bullet_upgrade = False
        self.activate_Bomb_upgrade = False
        self.fuel_bar = FuelBar( screen = screen, start_fuel = self.fuel_left,
                                 colour = colour)
    def check_for_max_v(self):
        (x,y) = self.get_velocity()
        if x>Ship.MAX_V or y>Ship.MAX_V or x<-Ship.MAX_V or y<-Ship.MAX_V:
            return True
    def thrust (self):
        angle = self.angle ()
        change_in_v = angle_and_length (angle, Ship.THRUST)
        v = self.get_velocity ()
        new_v = add_vectors (v, change_in_v)
        self.set_velocity (new_v)
    def moved (self):
        if self.ship == 1:
            Planet.player1_pos = self.pos()
        if self.ship == 2:
            Planet.player2_pos = self.pos()
        self.keep_to_screen()
        self.check_for_hits()
        self.gravitate ()
        if self.bullet_rof > 0:
            self.bullet_rof -= 1
        if self.missile_rof > 0:
            self.missile_rof -= 1
        if self.mine_rof > 0:
            self.mine_rof -= 1
        if self.bomb_rof > 0:
            self.bomb_rof -= 1
        if self.screen.is_pressed (self.key_left) and self.quick_turn_left > 20:
            self.rotate_by (-4.5)
            self.fuel_left = self.fuel_left - 0.25
        elif self.screen.is_pressed (self.key_right) and self.quick_turn_right > 20:
            self.rotate_by (+4.5)
            self.fuel_left = self.fuel_left - 0.25
        elif self.screen.is_pressed (self.key_left):
            self.quick_turn_left += 1
            self.quick_turn_right = 0
            self.rotate_by (-1.5)
            self.fuel_left = self.fuel_left - 0.10
        elif self.screen.is_pressed (self.key_right):
            self.quick_turn_right += 1
            self.quick_turn_left = 0
            self.rotate_by (+1.5)
            self.fuel_left = self.fuel_left - 0.10
        else:
            self.quick_turn_left = 0
            self.quick_turn_right = 0
        if self.screen.is_pressed (self.key_fire) and self.bullet_rof == 0:
            self.fire ()
            self.bullet_rof = 10
        elif self.screen.is_pressed (self.key_fire_missile) and self.missile_rof == 0:
            self.fire_missile ()
            self.missile_rof = 30
        elif self.screen.is_pressed (self.key_fire_bomb) and self.bomb_rof == 0:
            self.fire_bomb ()
            self.bomb_rof = 50
        elif self.screen.is_pressed (self.key_drop_mine) and self.mine_rof == 0:
            self.drop_mine ()
            self.mine_rof = 75
        if self.screen.is_pressed (self.key_thrust) and self.fuel_left > 0:
            self.fuel_left = self.fuel_left - 0.5
            if self.check_for_max_v() != True: 
                self.thrust ()
                self.fuel_left = self.fuel_left - 0.5
        self.fuel_bar.update(self.fuel_left)
    def fire (self):
        bullet = Bullet (screen = self.screen, ship_pos = self.pos (),
                         ship_velocity = self.get_velocity (),
                         ship_angle = self.angle ())
        if self.activate_Bullet_upgrade == True:
            for x in 15, -15:
                angle = self.angle() + x
                bullet = Bullet (screen = self.screen, ship_pos = self.pos (),
                                 ship_velocity = self.get_velocity (),
                                 ship_angle = angle)
                
    def fire_missile (self):
        missile = Missile (screen = self.screen, ship_pos = self.pos (),
                           ship_velocity = self.get_velocity (),
                           ship_angle = self.angle (),
                           activate_upgrade = self.activate_Missile_upgrade,
                           ship = self.ship)
    def fire_bomb (self):
        bomb = Bomb (screen = self.screen, ship_pos = self.pos (),
                     ship_velocity = self.get_velocity (),
                     ship_angle = self.angle (),
                     activate_upgrade = self.activate_Bomb_upgrade)
    def drop_mine (self):
        mine = Mine (screen = self.screen, ship_pos = self.pos (),
                     ship_velocity = self.get_velocity (),
                     ship_angle = self.angle (),
                     activate_upgrade = self.activate_Mine_upgrade)
    def lose_game (self):
        if not Ship.game_over:
            Ship.game_over = 1
            my_screen.clear()
            self.destroy()
            my_planet = Planet (screen = my_screen)
            check_play_again(screen = self.screen)
            message = games.Text (screen=self.screen, x=self.x, y=self.y,
            text = "You lost", size = 50, colour = self.colour)
    def drawn_game (self):
        if not Ship.game_over:
            Ship.game_over = 1
            my_screen.clear()
            my_planet = Planet (screen = my_screen)
            check_play_again(screen = self.screen)
            message = games.Text (screen=self.screen, x=CENTRE_X, y=CENTRE_Y-100,
            text = "Draw", size = 50, colour = colour.light_grey)
    def respawn(self, lives_left, lives_left_ant, Default):
        if Default == True:
            self.fuel_bar.destroy()
            self.destroy()
            FuelBar.num_bars = 0
            my_ship1 = Ship (screen = my_screen, x = SCREENWIDTH/6, y = CENTRE_Y,
                             colour = colour.red, key_left = games.K_a,
                             key_right = games.K_d, key_thrust = games.K_w,
                             key_fire = games.K_t, key_fire_missile = games.K_y,
                             key_drop_mine = games.K_u, key_fire_bomb = games.K_i, ship = 1,
                             lives = lives_left)
            my_ship2 = Ship (screen = my_screen, x = SCREENWIDTH/1.2, y = CENTRE_Y,
                             colour = colour.green, key_left = games.K_LEFT,
                             key_right = games.K_RIGHT, key_thrust = games.K_UP,
                             key_fire = games.K_KP1, key_fire_missile = games.K_KP2,
                             key_drop_mine = games.K_KP3, key_fire_bomb = games.K_KP4, ship = 2,
                             lives = lives_left_ant)
        elif self.ship == 1:
            self.fuel_bar.destroy()
            self.destroy()
            FuelBar.num_bars = 0
            my_ship1 = Ship (screen = my_screen, x = SCREENWIDTH/6, y = CENTRE_Y,
                colour = colour.red, key_left = games.K_a,
                key_right = games.K_d, key_thrust = games.K_w,
                key_fire = games.K_t, key_fire_missile = games.K_y,
                key_drop_mine = games.K_u, key_fire_bomb = games.K_i, ship = 1,
                lives = lives_left)
        elif self.ship == 2:
            self.fuel_bar.destroy()
            self.destroy()
            FuelBar.num_bars = 1
            my_ship2 = Ship (screen = my_screen, x = SCREENWIDTH/1.2, y = CENTRE_Y,
                colour = colour.green, key_left = games.K_LEFT,
                key_right = games.K_RIGHT, key_thrust = games.K_UP,
                key_fire = games.K_KP1, key_fire_missile = games.K_KP2,
                key_drop_mine = games.K_KP3, key_fire_bomb = games.K_KP4, ship = 2,
                lives = lives_left)
    def hit (self, what_hit_me):
        if isinstance( what_hit_me, FuelSupply) and isinstance( what_hit_me, Planet) != True and isinstance( what_hit_me, Ship) != True:
            self.fuel_left += 100
            if self.fuel_left > Ship.MAX_FUEL:
                self.fuel_left = Ship.MAX_FUEL
        elif isinstance( what_hit_me, MineUpgrade) and isinstance( what_hit_me, Planet) != True and isinstance( what_hit_me, Ship) != True:
            self.activate_Mine_upgrade = True
        elif isinstance( what_hit_me, MissileUpgrade) and isinstance( what_hit_me, Planet) != True and isinstance( what_hit_me, Ship) != True:
            self.activate_Missile_upgrade = True
        elif isinstance( what_hit_me, BulletUpgrade) and isinstance( what_hit_me, Planet) != True and isinstance( what_hit_me, Ship) != True:
            self.activate_Bullet_upgrade = True
        elif isinstance( what_hit_me, BombUpgrade) and isinstance( what_hit_me, Planet) != True and isinstance( what_hit_me, Ship) != True:
            self.activate_Bomb_upgrade = True 

        elif isinstance( what_hit_me, FuelBar) and isinstance( what_hit_me, Ship) != True:
            pass
        elif isinstance( what_hit_me, Ship) and self.live == 0:
            if what_hit_me.colour == self.colour:
                what_hit_me.destroy()
            if self.ship == 1:
                if my_ship2.live == 0:
                    self.drawn_game()
            if self.ship == 2:
                if my_ship1.live == 0:
                    self.drawn_game()
        elif isinstance( what_hit_me, Planet) and self.live == 0:
            self.lose_game()
        elif self.live > 0:
            if isinstance( what_hit_me, Ship):
                if what_hit_me.colour == self.colour:
                    what_hit_me.destroy()
                    what_hit_me.fuel_bar.destroy()
                elif self.ship == 1:
                    print self.live
                    live = my_ship2.live - 1
                    print my_ship2.live
                    my_ship2.live = my_ship2.live - 1
                    self.live = self.live - 1
                    what_hit_me.destroy()
                    what_hit_me.fuel_bar.destroy()
                    self.respawn(lives_left = self.live, lives_left_ant = live, Default = True)
                elif self.ship == 2:
                    self.live = self.live - 1
                    live = my_ship1.live - 1
                    my_ship1.live = my_ship1.live - 1
                    what_hit_me.destroy()
                    what_hit_me.fuel_bar.destroy()
                    self.respawn(lives_left = self.live, lives_left_ant = live, Default = True)
            else:
                self.live = self.live - 1
                if isinstance (what_hit_me,Planet) != True:
                    what_hit_me.check_for_hits()
            self.respawn(lives_left = self.live, lives_left_ant = 0, Default = False)      
        else:
            print what_hit_me
            self.lose_game()
        


    
my_screen = games.Screen (width = SCREENWIDTH, height = SCREENHEIGHT)
stars = games.load_image ("stars.bmp")
my_screen.set_background (stars)
my_planet = Planet (screen = my_screen)
my_ship1 = Ship (screen = my_screen, x = SCREENWIDTH/6, y = CENTRE_Y,
                colour = colour.red, key_left = games.K_a,
                key_right = games.K_d, key_thrust = games.K_w,
                key_fire = games.K_t, key_fire_missile = games.K_y,
                key_drop_mine = games.K_u, key_fire_bomb = games.K_i, ship = 1,
                 lives = 5)
my_ship2 = Ship (screen = my_screen, x = SCREENWIDTH/1.2, y = CENTRE_Y,
                colour = colour.green, key_left = games.K_LEFT,
                key_right = games.K_RIGHT, key_thrust = games.K_UP,
                key_fire = games.K_KP1, key_fire_missile = games.K_KP2,
                key_drop_mine = games.K_KP3, key_fire_bomb = games.K_KP4, ship = 2,
                 lives = 5)
my_screen.mainloop ()

