#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys, pygame, random, math, pyganim, os

size = (width, height) = (800, 600)

screen = pygame.display.set_mode(size)
pygame.display.set_caption("Ship")

pygame.init()
pygame.mixer.set_num_channels(16)


diagonal_2 = width**2 + height**2
score = 0
time_shift = 0

ship_2_im = pygame.image.load("ship_2.png")
ship_1_im = pygame.image.load("ship_1.png")
ship0_im = pygame.image.load("ship0.png")
ship1_im = pygame.image.load("ship1.png")
ship2_im = pygame.image.load("ship2.png")
ship_2_mask = pygame.mask.from_surface(ship_2_im)
ship_1_mask = pygame.mask.from_surface(ship_1_im)
ship0_mask = pygame.mask.from_surface(ship0_im)
ship1_mask = pygame.mask.from_surface(ship1_im)
ship2_mask = pygame.mask.from_surface(ship2_im)

list_of_ships = [ship0_im, ship1_im, ship2_im, ship_2_im, ship_1_im]
list_of_masks = [ship0_mask, ship1_mask, ship2_mask, ship_2_mask, ship_1_mask]

galaxy_im = pygame.image.load("galaxy.png").convert()
menu_im = pygame.image.load("menu.png")
cross_im = pygame.image.load("cross.png")
star_im = pygame.image.load("star.png")
blaster_im = pygame.image.load("blaster.png")
rocket_im = pygame.image.load("rocket.png")
lazer1_im = pygame.image.load("lazer1.png")
lazer2_im = pygame.image.load("lazer2.png")

gun_2_im = pygame.image.load("gun_2.png")
gun_1_im = pygame.image.load("gun_1.png")
gun0_im = pygame.image.load("gun0.png")
gun1_im = pygame.image.load("gun1.png")
gun2_im = pygame.image.load("gun2.png")

list_of_guns = [gun0_im, gun1_im, gun2_im, gun_2_im, gun_1_im]

double_gun_2_im = pygame.image.load("double_gun_2.png")
double_gun_1_im = pygame.image.load("double_gun_1.png")
double_gun0_im = pygame.image.load("double_gun0.png")
double_gun1_im = pygame.image.load("double_gun1.png")
double_gun2_im = pygame.image.load("double_gun2.png")

list_of_double_guns = [double_gun0_im, double_gun1_im, double_gun2_im, double_gun_2_im, double_gun_1_im]

polygun_2_im = pygame.image.load("polygun_2.png")
polygun_1_im = pygame.image.load("polygun_1.png")
polygun0_im = pygame.image.load("polygun0.png")
polygun1_im = pygame.image.load("polygun1.png")
polygun2_im = pygame.image.load("polygun2.png")

list_of_polyguns = [polygun0_im, polygun1_im, polygun2_im, polygun_2_im, polygun_1_im]

armor_2_im = pygame.image.load("armor_2.png")
armor_1_im = pygame.image.load("armor_1.png")
armor0_im = pygame.image.load("armor0.png")
armor1_im = pygame.image.load("armor1.png")
armor2_im = pygame.image.load("armor2.png")

list_of_armors = [armor0_im, armor1_im, armor2_im, armor_2_im, armor_1_im]

flare_gun_2_im = pygame.image.load("flare_gun_2.png")
flare_gun_1_im = pygame.image.load("flare_gun_1.png")
flare_gun0_im = pygame.image.load("flare_gun0.png")
flare_gun1_im = pygame.image.load("flare_gun1.png")
flare_gun2_im = pygame.image.load("flare_gun2.png")

list_of_flare_guns = [flare_gun0_im, flare_gun1_im, flare_gun2_im, flare_gun_2_im, flare_gun_1_im]

extra_gun_2_im = pygame.image.load("extra_gun_2.png")
extra_gun_1_im = pygame.image.load("extra_gun_1.png")
extra_gun0_im = pygame.image.load("extra_gun0.png")
extra_gun1_im = pygame.image.load("extra_gun1.png")
extra_gun2_im = pygame.image.load("extra_gun2.png")

list_of_extra_guns = [extra_gun0_im, extra_gun1_im, extra_gun2_im, extra_gun_2_im, extra_gun_1_im]

lazer_gun_2_im = pygame.image.load("lazer_gun_2.png")
lazer_gun_1_im = pygame.image.load("lazer_gun_1.png")
lazer_gun0_im = pygame.image.load("lazer_gun0.png")
lazer_gun1_im = pygame.image.load("lazer_gun1.png")
lazer_gun2_im = pygame.image.load("lazer_gun2.png")

list_of_lazer_guns = [lazer_gun0_im, lazer_gun1_im, lazer_gun2_im, lazer_gun_2_im, lazer_gun_1_im]

bonus_for_double_gun_im = pygame.image.load("bonus_for_double_gun.png")
bonus_for_armor_im = pygame.image.load("bonus_for_armor.png")
bonus_for_rocket_im = pygame.image.load("bonus_for_rocket.png")
bonus_for_polygun_im = pygame.image.load("bonus_for_polygun.png")
bonus_for_extra_gun_im = pygame.image.load("bonus_for_extra_gun.png")
bonus_for_25_repair_im = pygame.image.load("bonus_for_25_repair.png")
bonus_for_lazer_im = pygame.image.load("bonus_for_lazer.png")

ufo_im = pygame.image.load("ufo.png")
armor_ufo_im = pygame.image.load("armor_ufo.png")
armor_ufo1_im = pygame.image.load("armor_ufo1.png")
ufo_weapon_im = pygame.image.load("ufo_weapon.png")
bird_ship_im = pygame.image.load("bird_ship.png")
bird_ship1_im = pygame.image.load("bird_ship1.png")
bird_ship2_im = pygame.image.load("bird_ship2.png")
bird_ship3_im = pygame.image.load("bird_ship3.png")
bird_ship_weapon_im = pygame.image.load("bird_ship_weapon.png")
cosmo_ship_im = pygame.image.load("cosmo_ship.png")
cosmo_ship1_im = pygame.image.load("cosmo_ship1.png")
cosmo_ship2_im = pygame.image.load("cosmo_ship2.png")
cosmo_ship3_im = pygame.image.load("cosmo_ship3.png")
cosmo_ship_weapon_im = pygame.image.load("cosmo_ship_weapon.png")
aero_ship_im = pygame.image.load("aero_ship.png")
aero_ship1_im = pygame.image.load("aero_ship1.png")
aero_ship2_im = pygame.image.load("aero_ship2.png")
aero_ship3_im = pygame.image.load("aero_ship3.png")
aero_ship_weapon_im = pygame.image.load("aero_ship_weapon.png")


muse_dir = os.curdir + "\music\\"
list_of_authors = os.listdir(muse_dir)
author = dict()
my_music = []
for auth in list_of_authors:
    music_of_auth = os.listdir(muse_dir + str(auth) + '\\')
    for music in music_of_auth:
        author[music] = auth
    my_music += music_of_auth

play_list = random.shuffle(my_music)
cur = 0
pygame.mixer.music.load(muse_dir + author[my_music[cur]] + '\\' + my_music[cur])
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play()
cur += 1


muse_blaster = pygame.mixer.Sound("muse_blaster.ogg")
muse_blaster.set_volume(0.3)
muse_rocket = pygame.mixer.Sound("muse_rocket.ogg")
muse_rocket.set_volume(0.15)
muse_ufo_weapon = pygame.mixer.Sound("muse_ufo_weapon.ogg")
muse_ufo_weapon.set_volume(0.4)
muse_enemy_blaster = pygame.mixer.Sound("muse_enemy_laser.ogg")
muse_enemy_blaster.set_volume(0.4)
muse_small_bah = pygame.mixer.Sound("muse_small_bah.ogg")
muse_small_bah.set_volume(0.43)
muse_aimed = pygame.mixer.Sound("muse_aimed.ogg")
muse_aimed.set_volume(0.2)
muse_lazer = pygame.mixer.Sound("muse_lazer.ogg")
muse_lazer.set_volume(0.3)


class Star(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = star_im
        self.rect = self.image.get_rect()
        self.speed = 5
    def reset_pos(self):
        self.rect.x = width
        self.rect.y = random.randrange(height)
    def update(self):
        self.rect.x -= self.speed
        if self.rect.x <= 0:
            self.reset_pos()

class Ship(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = ship0_im
        self.rect = self.image.get_rect()
        self.mask = ship0_mask
        self.rect.x = self.rect.width + 100
        self.rect.y = height / 2
        self.width = self.rect[2]
        self.height = self.rect[3]
        self.life = 3
        self.health = 50
        self.damage = 15
        self.speed = 4
        self.x_speed = 0
        self.y_speed = 0
        self.state = 0
        self.begin_anim = 0
        self.we_begin = False
        self.gun = True
        self.double_gun = False
        self.polygun = False
        self.armor = False
        self.flare_gun = False
        self.extra_gun = False
        self.lazer_gun = False
        self.has_lazer = False
        self.has_one_lazer = False
        self.has_three_lazer = False
        self.has_weapon = self.double_gun or self.flare_gun or self.polygun or self.lazer_gun
        self.time_for_weapon = 0.0
        self.time_for_armor = 0.0
        self.begin_weapon = 0.0
        self.begin_armor = 0.0
        self.weapon_print = 0
        self.armor_print = 0
        self.time_for_blaster = 160
        self.time_for_rocket = 190
        self.time_for_lazer = 250
        self.time_last_blaster = -time_shift
        self.time_last_rocket = -time_shift
        self.can_fire_blaster = True
        self.can_fire_rocket = True
    def new_life(self):
        play_an_effect(muse_small_bah)
        self.life -= 1
        self.health = 50
        self.double_gun = False
        self.flare_gun = False
        self.lazer_gun = False
        self.has_lazer = False
        self.has_one_lazer = False
        self.has_three_lazer = False
        self.time_for_weapon = 0.0
        self.begin_armor = pygame.time.get_ticks() - time_shift
        self.armor = True
        self.time_for_armor = 6000
        self.extra_gun = False
        self.polygun = False
        self.has_weapon = False
        self.can_fire_blaster = True
        self.can_fire_rocket = True
        if not self.gun:
            self.gun = True
            gun = Gun(self.rect.x, self.rect.y)
            ship_weapon_list.add(gun)
    def update(self, must_update):
        if pygame.time.get_ticks() - time_shift - self.time_last_blaster >= self.time_for_blaster:
            self.can_fire_blaster = True
        if pygame.time.get_ticks() - time_shift - self.time_last_rocket >= self.time_for_rocket:
            self.can_fire_rocket = True
        self.has_weapon = self.double_gun or self.flare_gun or self.polygun or self.lazer_gun
        if not self.has_lazer:
            self.has_one_lazer = False
            self.has_three_lazer = False
        if self.has_weapon:
            self.weapon_print = int((self.time_for_weapon - (pygame.time.get_ticks() - self.begin_weapon - time_shift)) // 1000)
            if pygame.time.get_ticks() - self.begin_weapon - time_shift >= self.time_for_weapon:
                self.time_for_weapon = 0.0
                self.double_gun = False
                self.flare_gun = False
                self.polygun = False
                self.lazer_gun = False
                self.has_lazer = False
        if self.armor:
            self.armor_print = int((self.time_for_armor - (pygame.time.get_ticks() - self.begin_armor - time_shift)) // 1000)
            if pygame.time.get_ticks() - self.begin_armor - time_shift >= self.time_for_armor:
                self.time_for_armor = 0.0
                self.armor = False
        if not self.gun and not self.has_weapon:
            gun = Gun(self.rect.x, self.rect.y)
            self.gun = True
            ship_weapon_list.add(gun)
        global up, down, time_begin_up, time_begin_down

        if not up and not down:
            if self.state != 0:
                if not self.we_begin:
                    self.begin_anim = pygame.time.get_ticks() - time_shift
                    self.we_begin = True
                if self.state == 2:
                    if pygame.time.get_ticks() - self.begin_anim - time_shift >= 200:
                        self.state = 1
                        self.begin_anim = pygame.time.get_ticks() - time_shift
                elif self.state == -2:
                    if pygame.time.get_ticks() - self.begin_anim - time_shift >= 200:
                        self.state = -1
                        self.begin_anim = pygame.time.get_ticks() - time_shift
                if pygame.time.get_ticks() - self.begin_anim - time_shift >= 400:
                    self.state = 0
                    self.we_begin = False
        else:
            if up and not down:
                if self.state == 2 and pygame.time.get_ticks() - time_begin_up - time_shift >= 700:
                    self.state = 1
                    time_begin_up = pygame.time.get_ticks() - time_shift
                elif self.state == 1 and pygame.time.get_ticks() - time_begin_up - time_shift >= 500:
                    self.state = 0
                    time_begin_up = pygame.time.get_ticks() - time_shift
                elif self.state == 0 and pygame.time.get_ticks() - time_begin_up - time_shift >= 500:
                    self.state = -1
                    time_begin_up = pygame.time.get_ticks() - time_shift
                elif self.state == -1 and pygame.time.get_ticks() - time_begin_up - time_shift >= 700:
                    self.state = -2
                    time_begin_up = pygame.time.get_ticks() - time_shift

            if down and not up:
                if self.state == -2 and pygame.time.get_ticks() - time_begin_down - time_shift >= 700:
                    self.state = -1
                    time_begin_down = pygame.time.get_ticks() - time_shift
                elif self.state == -1 and pygame.time.get_ticks() - time_begin_down - time_shift >= 500:
                    self.state = 0
                    time_begin_down = pygame.time.get_ticks() - time_shift
                elif self.state == 0 and pygame.time.get_ticks() - time_begin_down - time_shift >= 500:
                    self.state = 1
                    time_begin_down = pygame.time.get_ticks() - time_shift
                elif self.state == 1 and pygame.time.get_ticks() - time_begin_down - time_shift >= 700:
                    self.state = 2
                    time_begin_down = pygame.time.get_ticks() - time_shift
        if self.armor:
            self.image = list_of_armors[self.state]
        else:
            self.image = list_of_ships[self.state]
        self.mask = list_of_masks[self.state]
        prev_x, prev_y = self.rect.x, self.rect.y
        self.rect = self.image.get_rect()
        self.rect.x, self.rect.y = prev_x, prev_y
        self.width = self.rect[2]
        self.height = self.rect[3]
        if must_update:
            self.rect.x += self.x_speed
            self.rect.y += self.y_speed

player = Ship()

def rad(degree):
    return degree * math.pi / 180

def degree(rad):
    return rad * 180 / math.pi


class Blaster(pygame.sprite.Sprite):
    def __init__(self, x, y, angle = 0): # > 0 rotate counterclockwise, angle in degrees
        pygame.sprite.Sprite.__init__(self)
        self.image = blaster_im
        self.image = pygame.transform.rotate(self.image, angle)
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = x
        self.rect.y = y
        self.type = 'Blaster'
        self.damage = 2
        self.speed = 7
        self.x_speed = self.speed * math.cos(rad(angle))
        self.y_speed = -self.speed * math.sin(rad(angle))
        play_an_effect(muse_blaster)
    def update(self, must_update):
        if self.rect.x > width or self.rect.y < 0 or self.rect.y > height:
            self.kill()
        self.rect.x += self.x_speed
        self.rect.y += self.y_speed

class Rocket(pygame.sprite.Sprite):
    def __init__(self, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = rocket_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = x
        self.rect.y = y
        self.type = 'Rocket'
        self.damage = 5
        self.speed = 8
        #self.smoke = pyganim.PygAnimation([(smoke1_im, 0.2), (smoke2_im, 0.2)])
        #self.smoke.play()
        play_an_effect(muse_rocket)
    def update(self, must_update):
        if self.rect.x > width:
            self.kill()
        self.rect.x += self.speed

class Lazer(pygame.sprite.Sprite):
    def __init__(self, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = lazer1_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = x + 55
        self.rect.y = y + 18
        self.image = lazer_gun2_im
        self.type = 'Lazer'
        self.damage = 3
        self.anim = pyganim.PygAnimation([(lazer1_im, 0.3), (lazer2_im, 0.3)])
        self.anim.play()
        play_an_effect(muse_lazer, -1)
    def update(self, must_update):
        if not player.has_lazer or not player.lazer_gun:
            muse_lazer.stop()
            self.kill()
        if must_update:
            self.rect.x += player.x_speed
            self.rect.y += player.y_speed
    def draw_anim(self):
        self.anim.blit(screen, (self.rect.x, self.rect.y))




class Ship_weapons(pygame.sprite.Sprite):
    def __init__(self, x, y, image, list_of):
        pygame.sprite.Sprite.__init__(self)
        self.image = image
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.list_elem = list_of
    def update(self, must_update):
        self.image = self.list_elem[player.state]
        if must_update:
            self.rect.x += player.x_speed
            self.rect.y += player.y_speed


class Gun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, gun0_im, list_of_guns)
    def update(self, must_update):
        if not player.gun:
            self.kill()
        Ship_weapons.update(self, must_update)

gun = Gun(player.rect.x, player.rect.y)

class Double_gun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, double_gun0_im, list_of_double_guns)
    def update(self, must_update):
        if not player.double_gun:
            self.kill()
        Ship_weapons.update(self, must_update)


class Polygun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, polygun0_im, list_of_polyguns)
    def update(self, must_update):
        if not player.polygun:
            self.kill()
        Ship_weapons.update(self, must_update)


class Flare_gun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, flare_gun0_im, list_of_flare_guns)
    def update(self, must_update):
        if not player.flare_gun:
            self.kill()
        Ship_weapons.update(self, must_update)

class Extra_gun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, extra_gun0_im, list_of_extra_guns)
    def update(self, must_update):
        if not player.extra_gun:
            self.kill()
        Ship_weapons.update(self, must_update)


class Lazer_gun(Ship_weapons):
    def __init__(self, x, y):
        Ship_weapons.__init__(self, x, y, extra_gun0_im, list_of_lazer_guns)
    def update(self, must_update):
        if not player.lazer_gun:
            self.kill()
        Ship_weapons.update(self, must_update)

class Bonus_type():
    Double_gun = 1
    Armor = 2
    Flare_gun = 3
    Polygun = 4
    Extra_gun = 5
    Repair_25 = 6
    Lazer_gun = 7

picture = {Bonus_type.Double_gun :  bonus_for_double_gun_im, Bonus_type.Armor : bonus_for_armor_im, Bonus_type.Flare_gun : bonus_for_rocket_im,
           Bonus_type.Polygun : bonus_for_polygun_im, Bonus_type.Extra_gun : bonus_for_extra_gun_im, Bonus_type.Repair_25 : bonus_for_25_repair_im,
           Bonus_type.Lazer_gun : bonus_for_lazer_im}

fields_of_bonus_type = [Bonus_type.Double_gun, Bonus_type.Armor, Bonus_type.Flare_gun, Bonus_type.Polygun, Bonus_type.Extra_gun,
                        Bonus_type.Repair_25, Bonus_type.Lazer_gun]


class Bonus(pygame.sprite.Sprite):
    def __init__(self, bonus_type):
        pygame.sprite.Sprite.__init__(self)
        self.image = picture[bonus_type]
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.type = bonus_type
        self.rect.x = width
        self.rect.y = random.randrange(self.rect.height, height - self.rect.height)
        self.speed = -3
    def update(self):
        if self.rect.x + self.rect.width <= 0:
            self.kill()
        self.rect.x += self.speed


def dist2(obj1, obj2):
    return (obj1.rect.x - obj2.rect.x)**2 + (obj1.rect.y - obj2.rect.y)**2

class Ufos(pygame.sprite.Sprite):
    def __init__(self, image):
        pygame.sprite.Sprite.__init__(self)
        self.image = image
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = width
        self.rect.y = random.randrange(height - self.rect.height)
        self.speed = -2
        self.shot = False
        self.life = 0
        self.score = 0
        self.last_time_damaged = pygame.time.get_ticks() - time_shift
        self.can_be_damaged = False
        self.was_damaged = False
    def update(self):
        if self.rect.x + self.rect.width <= 0:
            self.kill()
        if pygame.time.get_ticks() - time_shift - self.last_time_damaged >= player.time_for_lazer:
            self.can_be_damaged = True
        self.rect.x += self.speed
    def shoot(self):
        if not self.shot and 4 * dist2(self, player) <= diagonal_2:
            weapon = Ufo_weapon(self.rect.x + 5, self.rect.y + 23)
            enemy_bullet_list.add(weapon)
            self.shot = True


class Ufo(Ufos):
    def __init__(self):
        Ufos.__init__(self, ufo_im)
        self.life = 1
        self.score = 1


class Armor_ufo(Ufos):
    def __init__(self):
        Ufos.__init__(self, armor_ufo_im)
        self.life = 3
        self.score = 5
        self.state = 0
    def update(self):
        Ufos.update(self)
        if self.state != 1 and self.life <= 1.5:
            self.image = armor_ufo1_im
            self.state = 1


def dxdy(x, y):
    ans = [-x + (player.rect.x + player.width * 1.0 / 2), -y + (player.rect.y + player.height * 1.0 / 2)]
    return ans

def near_int(x):
    return math.floor(x + 0.5)


class Ufo_weapon(pygame.sprite.Sprite):
    def __init__(self, x_center, y_center):
        pygame.sprite.Sprite.__init__(self)
        self.image = ufo_weapon_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = x_center
        self.rect.y = y_center
        self.speed = 4
        angle = dxdy(x_center, y_center)
        self.angle = math.atan2(angle[1], angle[0])
        self.x_speed = self.speed * math.cos(self.angle)
        self.y_speed = self.speed * math.sin(self.angle)
        self.damage = 2
        self.step = 1
        play_an_effect(muse_ufo_weapon)
    def update(self):
        if self.rect.x + self.rect.width <= 0 or self.rect.x - 10 >= width or self.rect.y >= height or self.rect.y + self.rect.height <= 0:
            self.kill()
        if self.step == 2:
            self.rect.x += near_int(self.step * self.x_speed)
            self.rect.y += near_int(self.step * self.y_speed)
            self.step = 0
        self.step += 1

class Bird_ship(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = bird_ship_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = width
        self.rect.y = random.randrange(height - self.rect.height)
        self.speed = -1
        self.shot = False
        self.life = 12
        self.score = 15
        self.prev_time = -time_shift
        self.state = 0
        self.last_time_damaged = pygame.time.get_ticks() - time_shift
        self.can_be_damaged = False
        self.was_damaged = False
    def update(self):
        if self.rect.x + self.rect.width <= 0:
            self.kill()
        if pygame.time.get_ticks() - time_shift - self.last_time_damaged >= player.time_for_lazer:
            self.can_be_damaged = True
        self.rect.x += self.speed
        if self.shot and pygame.time.get_ticks() - self.prev_time - time_shift >= 2000:
            self.shot = False
        if self.state != 1 and self.life <= 8 and self.life > 6:
            self.image = bird_ship1_im
            self.state = 1
        if self.state != 2 and self.life <= 6 and self.life > 4:
            self.image = bird_ship2_im
            self.state = 2
        if self.state != 3 and self.life <= 3:
            self.image = bird_ship3_im
            self.state = 3
    def shoot(self):
        if not self.shot and 4 * dist2(self, player) <= diagonal_2:
            weapon = Bird_ship_weapon(self.rect.x + 28, self.rect.y + 10)
            enemy_bullet_list.add(weapon)
            self.shot = True
            self.prev_time = pygame.time.get_ticks() - time_shift


class Enemy_blaster(pygame.sprite.Sprite):
    def __init__(self, x_center, y_center, image):
        pygame.sprite.Sprite.__init__(self)
        self.image = image
        angle = dxdy(x_center, y_center)
        self.image = pygame.transform.rotate(self.image, degree(math.atan2(-angle[1], angle[0])))
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = x_center - self.rect.width / 2
        self.rect.y = y_center - self.rect.height / 2
        self.angle = math.atan2(angle[1], angle[0])
        self.speed = 0
        self.x_speed = 0
        self.y_speed = 0
        self.damage = 0
        self.step = 1
        play_an_effect(muse_enemy_blaster)
    def count_x_y_speed(self):
        self.x_speed = self.speed * math.cos(self.angle)
        self.y_speed = self.speed * math.sin(self.angle)
    def update(self):
        if self.rect.x + self.rect.width <= 0 or self.rect.x >= width or self.rect.y >= height or self.rect.y + self.rect.height <= 0:
            self.kill()
        if self.step == 2:
            self.rect.x += near_int(self.step * self.x_speed)
            self.rect.y += near_int(self.step * self.y_speed)
            self.step = 0
        self.step += 1


class Bird_ship_weapon(Enemy_blaster):
    def __init__(self, x_center, y_center):
        Enemy_blaster.__init__(self, x_center, y_center, bird_ship_weapon_im)
        self.speed = 5.5
        self.damage = 5
        self.count_x_y_speed()


class Cosmo_ship(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = cosmo_ship_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = width
        self.rect.y = random.randrange(height - self.rect.height)
        self.speed = -0.5
        self.shot_weapon_1 = False
        self.shot_weapon_2 = False
        self.life = 30
        self.score = 35
        self.prev_time_weapon_1 = -time_shift
        self.prev_time_weapon_2 = -time_shift
        self.state = 0
        self.move_x = 0
        self.last_time_damaged = pygame.time.get_ticks() - time_shift
        self.can_be_damaged = False
        self.was_damaged = False
    def update(self):
        if self.rect.x + self.rect.width <= 0:
            self.kill()
        if pygame.time.get_ticks() - time_shift - self.last_time_damaged >= player.time_for_lazer:
            self.can_be_damaged = True
        self.move_x += self.speed
        if self.move_x == -1:
            self.rect.x += self.move_x;
            self.move_x = 0
        if self.shot_weapon_1 and pygame.time.get_ticks() - self.prev_time_weapon_1 - time_shift >= 2000:
            self.shot_weapon_1 = False
        if self.shot_weapon_2 and pygame.time.get_ticks() - self.prev_time_weapon_2 - time_shift >= 1500:
            self.shot_weapon_2 = False
        if self.state != 1 and self.life <= 24 and self.life > 15:
            self.image = cosmo_ship1_im
            self.state = 1
        if self.state != 2 and self.life <= 15 and self.life > 6:
            self.image = cosmo_ship2_im
            self.state = 2
        if self.state != 3 and self.life <= 6:
            self.image = cosmo_ship3_im
            self.state = 3
    def shoot(self):
        if not self.shot_weapon_1 and 4 * dist2(self, player) <= diagonal_2:
            weapon = Bird_ship_weapon(self.rect.x + 52, self.rect.y + 7)
            enemy_bullet_list.add(weapon)
            weapon = Bird_ship_weapon(self.rect.x + 52, self.rect.y + 25)
            enemy_bullet_list.add(weapon)
            self.shot_weapon_1 = True
            self.prev_time_weapon_1 = pygame.time.get_ticks() - time_shift
        if not self.shot_weapon_2 and 7 * dist2(self, player) <= diagonal_2:
            weapon = Cosmo_ship_weapon(self.rect.x, self.rect.y + 25)
            enemy_bullet_list.add(weapon)
            self.shot_weapon_2 = True
            self.prev_time_weapon_2 = pygame.time.get_ticks() - time_shift


class Cosmo_ship_weapon(Enemy_blaster):
    def __init__(self, x_center, y_center):
        Enemy_blaster.__init__(self, x_center, y_center, cosmo_ship_weapon_im)
        self.speed = 7
        self.damage = 10
        self.count_x_y_speed()


class Aero_ship(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = aero_ship_im
        self.rect = self.image.get_rect()
        self.mask = pygame.mask.from_surface(self.image)
        self.rect.x = width
        self.rect.y = random.randrange(height - self.rect.height)
        self.speed = -1
        self.shot_weapon_1 = False
        self.shot_weapon_2 = False
        self.cur_gun = 0
        self.life = 25
        self.score = 50
        self.prev_time_weapon_1 = -time_shift
        self.prev_time_weapon_2 = -time_shift
        self.state = 0
        self.move_x = 0
        self.last_time_damaged = pygame.time.get_ticks() - time_shift
        self.can_be_damaged = False
        self.was_damaged = False
    def update(self):
        if self.rect.x + self.rect.width <= 0:
            self.kill()
        if pygame.time.get_ticks() - time_shift - self.last_time_damaged >= player.time_for_lazer:
            self.can_be_damaged = True
        self.rect.x += self.speed
        if self.shot_weapon_1 and pygame.time.get_ticks() - self.prev_time_weapon_1 - time_shift >= 750:
            self.shot_weapon_1 = False
            self.cur_gun = (self.cur_gun + 1) % 3
        if self.shot_weapon_2 and pygame.time.get_ticks() - self.prev_time_weapon_2 - time_shift >= 3000:
            self.shot_weapon_2 = False
        if self.state != 1 and self.life <= 20 and self.life > 14:
            self.image = aero_ship1_im
            self.state = 1
        if self.state != 2 and self.life <= 14 and self.life > 6:
            self.image = aero_ship2_im
            self.state = 2
        if self.state != 3 and self.life <= 6:
            self.image = aero_ship3_im
            self.state = 3
    def shoot(self):
        if not self.shot_weapon_1 and 8.5 * dist2(self, player) <= diagonal_2:
            weapon = Cosmo_ship_weapon(self.rect.x + 15 + 26 * self.cur_gun, self.rect.y + 43)
            enemy_bullet_list.add(weapon)
            self.shot_weapon_1 = True
            self.prev_time_weapon_1 = pygame.time.get_ticks() - time_shift
        if not self.shot_weapon_2 and 2 * dist2(self, player) <= diagonal_2:
            weapon = Aero_ship_weapon(self.rect.x, self.rect.y + 33)
            enemy_bullet_list.add(weapon)
            self.shot_weapon_2 = True
            self.prev_time_weapon_2= pygame.time.get_ticks() - time_shift


class Aero_ship_weapon(Enemy_blaster):
    def __init__(self, x_center, y_center):
        Enemy_blaster.__init__(self, x_center, y_center, aero_ship_weapon_im)
        self.speed = 5.5
        self.damage = 20
        self.count_x_y_speed()


green = (0, 255, 0)
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
blue = (0, 0, 255)
grey = (183, 183, 183)
color_of_sound_button = menu_im.get_at((100, 100))
font = pygame.font.Font(None, 25)
done = False
clock = pygame.time.Clock()

star_list = pygame.sprite.Group()
ship_bullet_list = pygame.sprite.Group() # the shoted weapon form ship
ship_list = pygame.sprite.Group() #the player
ship_weapon_list = pygame.sprite.Group() #the weapon that ship has
enemy_list = pygame.sprite.Group() #the list of enemies
enemy_bullet_list = pygame.sprite.Group() #the shoted weapon from enemies
bonus_list = pygame.sprite.Group()
ufo_random_list = [0 for i in range(150)] + [1]
bonus_random_list = [0 for i in range(500)] + [1]
bird_ship_random_list = [0 for i in range(550)] + [1]
cosmo_ship_random_list = [0 for i in range(1400)] + [1]
aero_ship_random_list = [0 for i in range(1600)] + [1]

time_begin_up = 0
time_begin_down = 0
up = False
down = False
must_update = True
pause = False
begin_pause = 0
end_pause = 0
play_music = True
play_effects = True
ship_list.add(player)
ship_weapon_list.add(gun)

def play_a_music(music, cnt = 0):
    if play_music:
        music.play(cnt)

def play_an_effect(effect, cnt = 0):
    if play_effects:
        effect.play(cnt)

muse_ship = pygame.mixer.Sound("muse_ship.ogg")
play_a_music(muse_ship, -1)

for i in range(400):
    star = Star()
    star.rect.x = random.randrange(width)
    star.rect.y = random.randrange(height)
    star_list.add(star)


cnt = 0

while not done:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
        if pause and event.type == pygame.MOUSEBUTTONDOWN:
            if event.button == 1:
                mouse_pos = pygame.mouse.get_pos()
                if mouse_pos[0] >= 250 + 18 and mouse_pos[0] <= 250 + 292 and mouse_pos[1] >= 100 + 14 and mouse_pos[1] <= 100 + 109:
                    play_music ^= 1
                if mouse_pos[0] >= 250 + 18 and mouse_pos[0] <= 250 + 292 and mouse_pos[1] >= 100 + 112 and mouse_pos[1] <= 100 + 207:
                    play_effects ^= 1
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_p:
                if not pause:
                    pause = True
                    up = False
                    down = False
                    player.x_speed = 0
                    player.y_speed = 0
                    begin_pause = pygame.time.get_ticks()
                else:
                    pause = False
                    end_pause = pygame.time.get_ticks()
                    time_shift += end_pause - begin_pause
                    if play_music:
                        pygame.mixer.music.unpause()
                    for bullet in ship_bullet_list:
                        if bullet.type == 'Lazer':
                            play_an_effect(muse_lazer, -1)
                    play_an_effect(muse_ship, -1)
                break
            if pause:
                break
            if event.key == pygame.K_RIGHT:
                player.x_speed += player.speed
            if event.key == pygame.K_LEFT:
                player.x_speed -= player.speed
            if event.key == pygame.K_UP:
                player.y_speed -= player.speed
                time_begin_up = pygame.time.get_ticks() - time_shift
                up = True
            if event.key == pygame.K_DOWN:
                player.y_speed += player.speed
                time_begin_down = pygame.time.get_ticks() - time_shift
                down = True
            if event.key == pygame.K_SPACE:
                if player.double_gun and player.can_fire_blaster:
                    blaster = Blaster(player.rect.x + player.width, player.rect.y + 22)
                    ship_bullet_list.add(blaster)
                    blaster = Blaster(player.rect.x + player.width, player.rect.y + 5)
                    ship_bullet_list.add(blaster)
                    if player.extra_gun:
                        blaster = Blaster(player.rect.x + 20, player.rect.y - 13)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y - 4)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 30)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 39)
                        ship_bullet_list.add(blaster)
                    player.time_last_blaster = pygame.time.get_ticks() - time_shift
                    player.can_fire_blaster = False
                elif player.flare_gun and player.can_fire_rocket:
                    rocket = Rocket(player.rect.x + 41, player.rect.y + 5)
                    ship_bullet_list.add(rocket)
                    rocket = Rocket(player.rect.x + 41, player.rect.y + 27)
                    ship_bullet_list.add(rocket)
                    if player.extra_gun:
                        rocket = Rocket(player.rect.x + 20, player.rect.y - 10)
                        ship_bullet_list.add(rocket)
                        rocket = Rocket(player.rect.x + 20, player.rect.y + 40)
                        ship_bullet_list.add(rocket)
                    player.time_last_rocket = pygame.time.get_ticks() - time_shift
                    player.can_fire_rocket = False
                elif player.polygun and player.can_fire_blaster:
                    blaster = Blaster(player.rect.x + 41, player.rect.y - 10, 45)
                    ship_bullet_list.add(blaster)
                    blaster = Blaster(player.rect.x + 48, player.rect.y - 6, 16)
                    ship_bullet_list.add(blaster)
                    blaster = Blaster(player.rect.x + player.width + 2, player.rect.y + 14)
                    ship_bullet_list.add(blaster)
                    blaster = Blaster(player.rect.x + 48, player.rect.y + 24, -22)
                    ship_bullet_list.add(blaster)
                    blaster = Blaster(player.rect.x + 45, player.rect.y + 25, -45)
                    ship_bullet_list.add(blaster)
                    if player.extra_gun:
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 10, 30)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 10, 8.2)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 10, -33)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 10, -11)
                        ship_bullet_list.add(blaster)
                    player.time_last_blaster = pygame.time.get_ticks() - time_shift
                    player.can_fire_blaster = False
                elif player.gun and player.can_fire_blaster:
                    blaster = Blaster(player.rect.x + player.width, player.rect.y + 22)
                    ship_bullet_list.add(blaster)
                    if player.extra_gun:
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 10)
                        ship_bullet_list.add(blaster)
                        blaster = Blaster(player.rect.x + 20, player.rect.y + 35)
                        ship_bullet_list.add(blaster)
                    player.time_last_blaster = pygame.time.get_ticks() - time_shift
                    player.can_fire_blaster = False
        if event.type == pygame.KEYUP:
            if pause:
                break
            if event.key == pygame.K_RIGHT:
                player.x_speed -= player.speed
            if event.key == pygame.K_LEFT:
                player.x_speed += player.speed
            if event.key == pygame.K_UP:
                player.y_speed += player.speed
                up = False
            if event.key == pygame.K_DOWN:
                player.y_speed -= player.speed
                down = False
    if not pause:
        list_of_keys = pygame.key.get_pressed()
        if list_of_keys[pygame.K_SPACE] and player.lazer_gun:
            if not player.has_one_lazer:
                lazer = Lazer(player.rect.x, player.rect.y)
                ship_bullet_list.add(lazer)
                player.has_one_lazer = True
            if player.extra_gun and not player.has_three_lazer:
                lazer = Lazer(player.rect.x - 5, player.rect.y + 25)
                ship_bullet_list.add(lazer)
                lazer = Lazer(player.rect.x - 5, player.rect.y - 25)
                ship_bullet_list.add(lazer)
                player.has_three_lazer = True
            player.has_lazer = True
        if not list_of_keys[pygame.K_SPACE] and player.lazer_gun and player.has_lazer:
            player.has_lazer = False
    if pause:
        screen.blit(menu_im, (250, 100))
        if play_music:
            pygame.mixer.music.pause()
        else:
            screen.blit(cross_im, (250, 100))
        if play_effects:
            muse_ship.stop()
            muse_lazer.stop()
        else:
            screen.blit(cross_im, (250, 198))
        pygame.display.flip()
        continue
    if not pygame.mixer.music.get_busy():
        pygame.mixer.music.load(muse_dir + author[my_music[cur]] + '\\' + my_music[cur])
        pygame.mixer.music.set_volume(0.5)
        pygame.mixer.music.play()
        cur += 1
    must_update = True
    cnt += 1
    if player.rect.x + player.x_speed < 0 or player.rect.x + player.width + player.x_speed > width or player.rect.y + player.y_speed <= 0 or player.rect.y + player.height + player.y_speed > height:
        must_update = False
    if player.state == 2 and up and player.rect.y + player.height > height:
        must_update = True
    star_list.update()
    ship_list.update(must_update)
    ship_weapon_list.update(must_update)
    ship_bullet_list.update(must_update)
    appear_bonus = random.choice(bonus_random_list)
    if appear_bonus:
        bonus_type = random.choice(fields_of_bonus_type)
        bonus = Bonus(bonus_type)
        bonus_list.add(bonus)
    for bonus in bonus_list:
        if pygame.sprite.collide_rect(player, bonus) and pygame.sprite.collide_mask(player, bonus):
            if bonus.type == Bonus_type.Double_gun:
                double_gun = Double_gun(player.rect.x, player.rect.y)
                ship_weapon_list.add(double_gun)
                if not player.has_weapon:
                    player.begin_weapon = pygame.time.get_ticks() - time_shift
                    player.has_weapon = True
                player.double_gun = True
                player.flare_gun = False
                player.polygun = False
                player.gun = False
                player.lazer_gun = False
                player.time_for_weapon += 11000
            elif bonus.type == Bonus_type.Armor:
                if not player.armor:
                    player.begin_armor = pygame.time.get_ticks() - time_shift
                player.armor = True
                player.time_for_armor += 11000
            elif bonus.type == Bonus_type.Flare_gun:
                flare_gun = Flare_gun(player.rect.x, player.rect.y)
                ship_weapon_list.add(flare_gun)
                if not player.has_weapon:
                    player.begin_weapon = pygame.time.get_ticks() - time_shift
                    player.has_weapon = True
                player.gun = False
                player.double_gun = False
                player.flare_gun = True
                player.polygun = False
                player.lazer_gun = False
                player.time_for_weapon += 11000
            elif bonus.type == Bonus_type.Polygun:
                polygun = Polygun(player.rect.x, player.rect.y)
                ship_weapon_list.add(polygun)
                if not player.has_weapon:
                    player.begin_weapon = pygame.time.get_ticks() - time_shift
                    player.has_weapon = True
                player.gun = False
                player.double_gun = False
                player.flare_gun = False
                player.polygun = True
                player.lazer_gun = False
                player.time_for_weapon += 11000
            elif bonus.type == Bonus_type.Extra_gun:
                if not player.extra_gun:
                    extra_gun = Extra_gun(player.rect.x, player.rect.y)
                    ship_weapon_list.add(extra_gun)
                    player.extra_gun = True
            elif bonus.type == Bonus_type.Repair_25:
                player.health = min(50, player.health + 25)
            elif bonus.type == Bonus_type.Lazer_gun:
                lazer_gun = Lazer_gun(player.rect.x, player.rect.y)
                ship_weapon_list.add(lazer_gun)
                if not player.has_weapon:
                    player.begin_weapon = pygame.time.get_ticks() - time_shift
                    player.has_weapon = True
                player.gun = False
                player.double_gun = False
                player.flare_gun = False
                player.polygun = False
                player.lazer_gun = True
                player.time_for_weapon += 11000
            bonus.kill()
    bonus_list.update()
    appear_ufo = random.choice(ufo_random_list)
    if appear_ufo:
        ufo_type = random.randrange(1, 3)
        if ufo_type == 1:
            ufo = Ufo()
        else:
            ufo = Armor_ufo()
        enemy_list.add(ufo)
    appear_bird_ship = random.choice(bird_ship_random_list)
    if appear_bird_ship:
        enemy_list.add(Bird_ship())
    appear_cosmo_ship = random.choice(cosmo_ship_random_list)
    if appear_cosmo_ship:
        enemy_list.add(Cosmo_ship())
    appear_aero_ship = random.choice(aero_ship_random_list)
    if appear_aero_ship:
        enemy_list.add(Aero_ship())
    enemy_list.update()
    for enemy in enemy_list:
        for weapon in ship_bullet_list:
            if pygame.sprite.collide_rect(enemy, weapon) and pygame.sprite.collide_mask(enemy, weapon):
                if weapon.type == 'Lazer' and enemy.can_be_damaged:
                    enemy.life -= weapon.damage
                    enemy.was_damaged = True
                    play_an_effect(muse_aimed)
                if weapon.type != 'Lazer':
                    enemy.life -= weapon.damage
                    weapon.kill()
                    play_an_effect(muse_aimed)
                if enemy.life <= 0:
                    play_an_effect(muse_small_bah)
                    score += enemy.score
                    if score // 500 > (score - enemy.score) // 500:
                        player.life += 1
                    enemy.kill()
                    break
        if enemy.was_damaged:
            enemy.last_time_damaged = pygame.time.get_ticks() - time_shift
            enemy.can_be_damaged = False
            enemy.was_damaged = False

    was_crush = False
    if not player.armor:
        for enemy in enemy_list:
            if pygame.sprite.collide_rect(player, enemy) and pygame.sprite.collide_mask(player, enemy):
                enemy.life -= player.damage
                was_crush = True
                if enemy.life <= 0:
                    score += enemy.score
                    if score // 500 > (score - enemy.score) // 500:
                        player.life += 1
                    enemy.kill()
                break
    if was_crush:
        player.new_life()
    for enemy in enemy_list:
        enemy.shoot()
    enemy_bullet_list.update()
    if not player.armor:
        for enemy_bullet in enemy_bullet_list:
            if pygame.sprite.collide_rect(player, enemy_bullet) and pygame.sprite.collide_mask(player, enemy_bullet):
                player.health -= enemy_bullet.damage
                enemy_bullet.kill()
                if player.health > 0:
                    play_an_effect(muse_aimed)
                else:
                    break
    if player.health <= 0:
        player.new_life()
    #screen.fill(black)
    screen.blit(galaxy_im, (0, 0))
    star_list.draw(screen)
    ship_list.draw(screen)
    ship_weapon_list.draw(screen)
    ship_bullet_list.draw(screen)
    for bullet in ship_bullet_list:
        if bullet.type == 'Lazer':
            bullet.draw_anim()
    bonus_list.draw(screen)
    enemy_list.draw(screen)
    enemy_bullet_list.draw(screen)
    txt_score = font.render("Score: " + str(score), True, white)
    txt_life = font.render("Life: " + str(player.life), True, white)
    txt_health = font.render("Health: " + str(player.health), True, white)
    if play_music:
        txt_music = font.render("Music track: " + my_music[cur - 1][:-4], True, white)
        txt_author = font.render("Author is: " + author[my_music[cur - 1]], True, white)
        screen.blit(txt_music, (0, 560))
        screen.blit(txt_author, (0, 580))
    else:
        txt_music = font.render("No music is playing now", True, white)
        screen.blit(txt_music, (0, 580))
    screen.blit(txt_score, (0, 0))
    screen.blit(txt_life, (150, 0))
    screen.blit(txt_health, (150, 20))
    pygame.draw.rect(screen, grey, (300, 20, 100, 15), 0)
    pygame.draw.rect(screen, green, (300, 20, player.health * 2, 15), 0)
    if player.double_gun:
        txt_time = font.render("Double gun: " + str(player.weapon_print), True, white)
        screen.blit(txt_time, (300, 0))
    if player.flare_gun:
        txt_time = font.render("Rocket: " + str(player.weapon_print), True, white)
        screen.blit(txt_time, (300, 0))
    if player.polygun:
        txt_time = font.render("Polygun: " + str(player.weapon_print), True, white)
        screen.blit(txt_time, (300, 0))
    if player.lazer_gun:
        txt_time = font.render("Lazer: " + str(player.weapon_print), True, white)
        screen.blit(txt_time, (300, 0))
    if player.armor:
        txt_armor = font.render("Armor: " + str(player.armor_print), True, white)
        screen.blit(txt_armor, (450, 0))
    pygame.display.flip()
    if player.life < 0:
        break
    clock.tick(80)

pygame.quit()