pygraph_5.py

import pygame
from random import choice, randint
from math import sqrt, asin, pi, sin, cos

f1 = open('info.txt').read().split('\n')
lvl = int(f1[0])
sasound = int(f1[1])
w = open("info.txt", 'w')
w.write(str(5) + '\n')
if sasound == 0:
    w.write(str(0) + '\n')
else:
    w.write(str(1) + '\n')
w.close()

obs = pygame.image.load('images/obstacle.png')
titry = pygame.image.load('images/titry.png')
goblin_l = pygame.image.load('images/skeletone_l.png')
obs.set_colorkey((255, 255, 255))
goblin_l.set_colorkey((255, 255, 255))
goblin_r = pygame.image.load('images/skeletone_r.png')
goblin_r.set_colorkey((255, 255, 255))
boss_l = pygame.image.load('images/boss_l.png')
boss_l.set_colorkey((255, 255, 255))
boss_r = pygame.image.load('images/boss_r.png')
boss_r.set_colorkey((255, 255, 255))
hero_l = pygame.image.load('images/not_bandit.png')
hero_l.set_colorkey((255, 255, 255))
hero_r = pygame.image.load('images/bandit.png')
hero_r.set_colorkey((255, 255, 255))
other_hero_l = pygame.image.load('images/other_hero_l.png')
other_hero_l.set_colorkey((255, 255, 255))
other_hero_r = pygame.image.load('images/other_hero_r.png')
other_hero_r.set_colorkey((255, 255, 255))
pol = pygame.image.load('images/pol_boss.png')
pol.set_colorkey((255, 255, 255))
wall_hor = pygame.image.load('images/wall_hor_boss.png')
wall_hor.set_colorkey((255, 255, 255))
wall_ver = pygame.image.load('images/wall_ver_boss.png')
wall_ver.set_colorkey((255, 255, 255))
rifle_l = pygame.image.load('images/rifle_l.png')
rifle_l.set_colorkey((24, 29, 35))
rifle_r = pygame.image.load('images/rifle_r.png')
rifle_r.set_colorkey((24, 29, 35))
bullet = pygame.image.load('images/bullet.png')
bullet.set_colorkey((255, 255, 255))
blade = pygame.image.load('images/blade.png')
blade.set_colorkey((255, 255, 255))
npc_bullet_l = pygame.image.load('images/npc_bullet_5_l.png')
npc_bullet_l.set_colorkey((255, 255, 255))
npc_bullet_r = pygame.image.load('images/npc_bullet_5_r.png')
npc_bullet_r.set_colorkey((255, 255, 255))
boss_bullet_l = pygame.image.load('images/boss_bullet_l.png')
boss_bullet_l.set_colorkey((255, 255, 255))
boss_bullet_r = pygame.image.load('images/boss_bullet_r.png')
boss_bullet_r.set_colorkey((255, 255, 255))
courpse = pygame.image.load('images/courpse_1.png')
courpse.set_colorkey((255, 255, 255))
hp_bar = pygame.image.load('images/health_points.png')
hp_bar.set_colorkey((255, 255, 255))
hc = pygame.image.load('images/hero_dead.png')
hc.set_colorkey((255, 255, 255))
walkthrough = pygame.image.load('images/walkthrough.png')
walkthrough.set_colorkey((255, 255, 255))
trade = pygame.image.load('images/trading.png')
trade.set_colorkey((255, 255, 255))
portal = pygame.image.load('images/portal.png')
portal.set_colorkey((255, 255, 255))
coin = pygame.image.load('images/coin.png')
coin.set_colorkey((255, 255, 255))
            
npc = []
bullets = []
npc_bullets = []
boss_bullets = []
bombs = []


aim = True
GG_1, GG_2 = False, False
courpses = []
room = 1

f1 = open('buffs.txt').read().split('\n')
hp_boost = int(f1[0])
damage_boost = int(f1[1])
speed_boost = int(f1[2])


class Boss:
    def __init__(self, x, y):
        self.nx = choice([-1, 1])
        self.ny = choice([-1, 1])
        self.y = y
        self.x = x
        self.hp = 1000
        self.spinner = 0
        self.damage = 2
        self.cd = 70
        self.stop = False

    def get_damage(self, amount):
        global courpses, coins
        self.hp -= amount
        if self.hp <= 0:
            courpses.append((self.x, self.y))
        
            
    
    def move(self, hp, stop):
        
        if self.spinner > 0:
            self.spinner -= 1
        if not stop and not self.stop:
            adder_1 = int(self.nx * v / fps * 2)
            adder_2 = int(self.ny * v / fps * 2)
            if self.x + adder_1 <= 30:
                self.nx *= -1
            if self.y + adder_2 <= 50:
                self.ny *= -1
            if self.x + adder_1 > 1200 - 270:
                self.nx *= -1
            if self.y + adder_2 > 800 - 270:
                self.ny *= -1
            if room == 2:
                if self.x + adder_1 in list(range(200, 350 + 380)) and self.y + adder_2 in list(range(160, 180 + 230)):
                    if not (self.x - adder_1 in list(range(200, 350 + 380)) and self.y + adder_2 in list(range(160, 180 + 230))):
                        self.nx = -self.nx
                    elif not (self.x + adder_1 in list(range(200, 350 + 380)) and self.y - adder_2 in list(range(160, 180 + 230))):
                        self.ny = -self.ny
                    else:
                        self.nx, self.ny = -1 * self.nx, -1 * self.ny
            adder_1 = int(self.nx * v / fps * 2)
            adder_2 = int(self.ny * v / fps * 2)
            self.x += adder_1
            self.y += adder_2
        if randint(0, 100) <= 3 and self.spinner > 0:
            self.x, self.y = randint(250, 900), randint(250, 550)
            while self.x in list(range(200, 350 + 380)) and self.y in list(range(160, 180 + 230)):
                self.x, self.y = randint(250, 900), randint(250, 550)
            self.nx, self.ny = choice([-1, 1]), choice([-1, 1])
        self.draw(hp)
        
    def draw(self, hp):
        self.stop = False
        if self.spinner > 0:
            g_l_r = blade.get_rect(
            topleft=(self.x - 100, self.y + 50))
            rot_image = pygame.transform.rotate(blade, choice(list(range(-80, 80))))
            rot_rect = rot_image.get_rect(center=g_l_r.center)
            rot_image.set_colorkey((255, 255, 255))
            screen.blit(rot_image, rot_rect)
            if sqrt((self.x - hero.x) ** 2 + (self.y + 100 - hero.y) ** 2) < 250:
                if self.spinner % 3 == 0:
                    hero.get_damage(1)
            if sqrt((self.x  - hero_2.x) ** 2 + (self.y + 100 - hero_2.y) ** 2) < 250:
                if self.spinner % 3 == 0:
                    hero_2.get_damage(1)
            self.stop = True
        if (sqrt((hero_2.x - self.x) ** 2 + (hero_2.y - self.y) ** 2) <= sqrt((hero.x - self.x) ** 2 + (hero.y - self.y) ** 2) and hero_2.hp > 0) or hero.hp <= 0:
            aim_x, aim_y = hero_2.x, hero_2.y
        else:
            aim_x, aim_y = hero.x, hero.y
        if aim_x < self.x:
            g_l_r = boss_l.get_rect(
                topleft=(self.x, self.y))
            screen.blit(boss_l, g_l_r)
        else:
            g_l_r = boss_r.get_rect(
                topleft=(self.x, self.y))
            screen.blit(boss_r, g_l_r)
        pygame.draw.rect(screen, (0, 0, 0), (self.x - 2, self.y - 12, 210, 12), 4)
        pygame.draw.rect(screen, (255, 0, 0), (self.x, self.y - 10, int(210 * hp / 1000), 10))
        


    def attack(self):
        at_type = choice([0, 1, 2, 3])
        if (sqrt((hero_2.x - self.x) ** 2 + (hero_2.y - self.y) ** 2) <= sqrt((hero.x - self.x) ** 2 + (hero.y - self.y) ** 2) and hero_2.hp > 0) or hero.hp <= 0:
            aim_x, aim_y = hero_2.x, hero_2.y
        else:
            aim_x, aim_y = hero.x, hero.y
        if at_type == 0:
            self.x += 100
            self.y += 100
            if aim_x > self.x:
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y + 100)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y - 100)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y + 50)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y - 50)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y + 75)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y - 75)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y + 25)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x + 100, self.y - 25)
                boss_bullets.append(bull)
            else:
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y + 100)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y - 100)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y + 50)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y - 50)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y + 75)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y - 75)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y + 25)
                boss_bullets.append(bull)
                bull = Boss_bullet(self.x, self.y, self.x - 100, self.y - 25)
                boss_bullets.append(bull)

            self.x -= 100
            self.y -= 100
        elif at_type == 1:
            if len(npc) <= 7:
                for i in range(choice(list(range(2, 5)))):
                    x_pos, y_pos = randint(50, 1100), randint(50, 700)
                    while x_pos in list(range(300, 350 + 380)) and y_pos in list(range(280, 180 + 320)):
                        x_pos, y_pos = randint(50, 1100), randint(50, 700)
                    ball = Goblin(x_pos, y_pos)
                    npc.append(ball)
            else:
                self.spinner = randint(20, 80)
        elif at_type == 2:
            for i in range(choice([5, 4, 3])):
                x_pos, y_pos = randint(50, 1100), randint(50, 700)
                ball = Bomb(x_pos, y_pos)
                bombs.append(ball)
        elif at_type == 3:
            self.spinner = randint(20, 80)

class Nepice:
    def __init__(self, x, y):
        self.nx = choice([-1, 1])
        self.ny = choice([-1, 1])
        self.y = y
        self.x = x
        self.hp = 4
        self.damage = 1
        self.cd = randint(85, 100)

    def get_damage(self, amount):
        global courpses, coins
        self.hp -= amount
        if self.hp <= 0:
            courpses.append((self.x, self.y))
        
            
    
    def move(self, hp, stop):
        if not stop:
            adder_1 = int(self.nx * v / fps * 2)
            adder_2 = int(self.ny * v / fps * 2)
            if self.x <= 30:
                self.nx *= -1
            if self.y <= 50:
                self.ny *= -1
            if self.x > 1200 - 120:
                self.nx *= -1
            if self.y > 800 - 120:
                self.ny *= -1
            if room == 2:
                if self.x + adder_1 in list(range(300, 350 + 380)) and self.y + adder_2 in list(range(280, 180 + 320)):
                    if not (self.x - adder_1 in list(range(300, 350 + 380)) and self.y + adder_2 in list(range(280, 180 + 320))):
                        self.nx = -self.nx
                    elif not (self.x + adder_1 in list(range(300, 350 + 380)) and self.y - adder_2 in list(range(280, 180 + 320))):
                        self.ny = -self.ny
                    else:
                        self.nx, self.ny = -1 * self.nx, -1 * self.ny
            adder_1 = int(self.nx * v / fps * 2)
            adder_2 = int(self.ny * v / fps * 2)
            self.x += adder_1
            self.y += adder_2
        self.draw(hp)
        
    def draw(self):
        pass

    def attack(self):
        if (sqrt((hero_2.x - self.x) ** 2 + (hero_2.y - self.y) ** 2) <= sqrt((hero.x - self.x) ** 2 + (hero.y - self.y) ** 2) and hero_2.hp > 0) or hero.hp <= 0:
            aim_x, aim_y = hero_2.x, hero_2.y
        else:
            aim_x, aim_y = hero.x, hero.y
        bullets.append(NPC_bullet(self.x, self.y, aim_x, aim_y))
        

boss = Boss(300, 100)

class Goblin(Nepice):
    def __init__(self, x, y):
        super().__init__(x, y)
        self.hp = 4
        
    def draw(self, hp):
        if self.nx == -1:
            g_l_r = goblin_l.get_rect(
                topleft=(self.x, self.y))
            screen.blit(goblin_l, g_l_r)
        else:
            g_l_r = goblin_r.get_rect(
                topleft=(self.x, self.y))
            screen.blit(goblin_r, g_l_r)
        pygame.draw.rect(screen, (0, 0, 0), (self.x - 2, self.y - 12, 72, 12), 4)
        pygame.draw.rect(screen, (255, 0, 0), (self.x, self.y - 10, int(70 * hp / 4), 10))
        

class Bomb:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.timer = 20

    def draw(self):
        self.timer -= 1
        if self.timer == 0:
            pygame.draw.circle(screen, (0, 0, 0), (self.x, self.y), 150)
            if sqrt((self.x - hero.x) ** 2 + (self.y - hero.y) ** 2) < 150:
                hero.get_damage(4)
            if sqrt((self.x  - hero_2.x) ** 2 + (self.y - hero_2.y) ** 2) < 150:
                hero_2.get_damage(4)
            return True
        else:
            pygame.draw.circle(screen, (int(255 * (1 - self.timer / 20)), 0, 0), (self.x, self.y), 150)
            return False

class Boss_bullet:
    def __init__(self, start_x, start_y, end_x, end_y):
        self.start_x = start_x
        self.start_y = start_y
        self.end_x = end_x
        self.end_y = end_y
        self.damage = 2
        self.x, self.y = self.start_x, self.start_y
        self.angle = int(asin((self.start_y - self.end_y) / sqrt((self.end_x - self.start_x) ** 2 + (self.end_y - self.start_y) ** 2)) / pi * 180)

    def draw(self):
        if self.start_x < self.end_x:
            self.x += 16 * abs(cos(self.angle * pi / 180))
        else:
            self.x -= 16 * abs(cos(self.angle * pi / 180))
        if self.start_y < self.end_y:
            self.y += 16 * abs(sin(self.angle * pi / 180))
        else:
            self.y -= 16 * abs(sin(self.angle * pi / 180))
        if self.x < 30 or self.x > 1112 or self.y < 30 or self.y > 680:
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        if int(self.x + 15) in list(range(int(hero_2.x), int(hero_2.x + 70))) and int(self.y + 6) in list(range(int(hero_2.y), int(hero_2.y + 70))) and not GG_2:
            hero_2.get_damage(self.damage)
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        elif int(self.x + 15) in list(range(int(hero.x), int(hero.x + 70))) and int(self.y + 6) in list(range(int(hero.y), int(hero.y + 70))) and not GG_1:
            hero.get_damage(self.damage)
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        if room == 2:
            if int(self.x + 50) in list(range(350, 350 + 380)) and int(self.y + 20) in list(range(320, 320 + 180)):
                pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
                return True
        g_l_r = boss_bullet_r.get_rect(
            topleft=(self.x, self.y))
        if self.start_x < self.end_x:
            rot_image = pygame.transform.rotate(boss_bullet_r, self.angle)
        else:
            rot_image = pygame.transform.rotate(boss_bullet_l, -self.angle)
        rot_rect = rot_image.get_rect(center=g_l_r.center)
        rot_image.set_colorkey((255, 255, 255))
        screen.blit(rot_image, rot_rect)
        return False




class NPC_bullet:
    def __init__(self, start_x, start_y, end_x, end_y):
        self.start_x = start_x
        self.start_y = start_y
        self.end_x = end_x
        self.end_y = end_y
        self.damage = 1
        self.x, self.y = self.start_x, self.start_y
        self.angle = int(asin((self.start_y - self.end_y) / sqrt((self.end_x - self.start_x) ** 2 + (self.end_y - self.start_y) ** 2)) / pi * 180)

    def draw(self):
        if self.start_x < self.end_x:
            self.x += 26 * abs(cos(self.angle * pi / 180))
        else:
            self.x -= 26 * abs(cos(self.angle * pi / 180))
        if self.start_y < self.end_y:
            self.y += 26 * abs(sin(self.angle * pi / 180))
        else:
            self.y -= 26 * abs(sin(self.angle * pi / 180))
        if self.x < 30 or self.x > 1112 or self.y < 30 or self.y > 680:
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        if int(self.x + 30) in list(range(int(hero_2.x), int(hero_2.x + 70))) and int(self.y + 4) in list(range(int(hero_2.y), int(hero_2.y + 70))) and not GG_2:
            hero_2.get_damage(self.damage)
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        elif int(self.x + 30) in list(range(int(hero.x), int(hero.x + 70))) and int(self.y + 4) in list(range(int(hero.y), int(hero.y + 70))) and not GG_1:
            hero.get_damage(self.damage)
            pygame.draw.circle(screen, (0, 0, 255), (self.x + 30, self.y + 55), 15)
            return True
        g_l_r = npc_bullet_r.get_rect(
            topleft=(self.x, self.y))
        if self.start_x < self.end_x:
            rot_image = pygame.transform.rotate(npc_bullet_r, self.angle)
        else:
            rot_image = pygame.transform.rotate(npc_bullet_l, -self.angle)
        if room == 2:
            if int(self.x + 30) in list(range(350, 350 + 380)) and int(self.y + 4) in list(range(320, 320 + 180)):
                pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
                return True

        rot_rect = rot_image.get_rect(center=g_l_r.center)
        rot_image.set_colorkey((255, 255, 255))
        screen.blit(rot_image, rot_rect)
        return False



class Hero_bullet:
    def __init__(self, start_x, start_y, end_x, end_y, damage=4, super_bullet=False):
        self.start_x = start_x
        self.start_y = start_y
        self.end_x = end_x
        self.end_y = end_y
        self.damage = damage + damage_boost
        self.x, self.y = self.start_x, self.start_y
        self.super_bullet = super_bullet
        try:
            self.angle = int(asin((self.start_y - self.end_y) / sqrt((self.end_x - self.start_x) ** 2 + (self.end_y - self.start_y) ** 2)) / pi * 180)
        except ZeroDivisionError:
            self.angle = int(asin((self.start_y - self.end_y) / 0.00000000000000001) / pi * 180)

    def draw(self):
        n = 16
        if self.super_bullet:
            n *= 2
        if self.start_x < self.end_x:
            self.x += n * abs(cos(self.angle * pi / 180))
        else:
            self.x -= n * abs(cos(self.angle * pi / 180))
        if self.start_y < self.end_y:
            self.y += n * abs(sin(self.angle * pi / 180))
        else:
            self.y -= n * abs(sin(self.angle * pi / 180))
        if self.x < 30 or self.x > 1112 or self.y < 30 or self.y > 680:
            pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
            return True
        for num, i in enumerate(npc):
            if int(self.x + 30) in list(range(int(i.x), int(i.x + 70))) and int(self.y + 50) in list(range(int(i.y), int(i.y + 50))):
                i.get_damage(self.damage)
                pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
                return True
        if room == 2:
            if int(self.x + 30) in list(range(350, 350 + 380)) and int(self.y + 50) in list(range(320, 320 + 180)):
                pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
                return True
        x = boss.x
        y = boss.y
        if int(self.x + 30) in list(range(int(x), int(x + 230))) and int(self.y + 50) in list(range(int(y), int(y + 230))):
            boss.get_damage(self.damage)
            pygame.draw.circle(screen, (255, 0, 0), (self.x + 30, self.y + 55), 15)
            return True
        if not self.super_bullet:
            g_l_r = bullet.get_rect(
                topleft=(self.x + 35, self.y + 50))
            screen.blit(bullet, g_l_r)
        else:
            hm = pygame.image.load('images/super_bullet.png')
            hm.set_colorkey((255, 255, 255))
            g_l_r = hm.get_rect(
                topleft=(self.x + 35, self.y + 50))
            screen.blit(hm, g_l_r)
        return False
                    

class Hero:
    def __init__(self, typer):
        self.x = typer * 350
        self.y = 600
        self.nx = 1
        self.tp = typer
        self.weapons = [[rifle_r, rifle_l]]
        self.curr_weapon = self.weapons[0]
        self.target_x = 1000
        self.target_y = 600
        self.angle = 0
        self.hp = 10 + hp_boost
        self.total = 10 + hp_boost
        self.cd = 0
        if typer == 1:
            self.typer_r = hero_r
            self.typer_l = hero_l
        else:
            self.typer_r = other_hero_r
            self.typer_l = other_hero_l
        self.draw()
            

    def get_damage(self, num):
        global GG_1, GG_2
        self.hp -= num
        if self.hp <= 0:
            if self.tp == 1:
                GG_1 = True
            else:
                GG_2 = True

    def move(self, m_x, m_y):
        m_x, m_y = m_x + m_x * (speed_boost * 15 / 100), m_y * (speed_boost * 15 / 100) + m_y        
        if ((GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2)):
            return
        if self.x + m_x <= 10:
            return
        if self.y + m_y <= 40:
            return
        if self.x + m_x > 1100:
            return
        if self.y + m_y > 800 - 125:
            return
        if room == 1 and self.x + m_x in list(range(0, 150)) and self.y + m_y in list(range(0, 200)):
            return
        if room == 2:
            if self.x + m_x + 60 in list(range(350, 350 + 380)) and self.y + m_y + 70 in list(range(320, 320 + 180)):
                return 
        self.x += m_x
        self.y += m_y
        if m_x < 0:
            self.nx = -1
        elif m_x > 0:
            self.nx = 1

    def target(self, x, y):
        self.target_x = x
        self.target_y = y
    
    def shoot(self, s_x=0, s_y=0):
        global bullets
        if self.cd == 0  and not ((GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2)):
            if aim or self.tp == 2:
                bull = Hero_bullet(self.x, self.y, self.target_x, self.target_y)
            else:
                bull = Hero_bullet(self.x, self.y, s_x, s_y)
            bullets.append(bull)
            self.cd = 10
            
    def ability(self):
        global h1_ab, h2_ab
        if self.tp == 1 and not GG_1:
            bull = Hero_bullet(self.x, self.y, self.x + 100, self.y)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 100, self.y)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x, self.y + 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x, self.y - 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 100, self.y + 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 100, self.y - 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 100, self.y + 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 100, self.y - 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 50, self.y + 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 50, self.y - 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 50, self.y + 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 50, self.y - 100)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 100, self.y + 50)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 100, self.y - 50)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x - 100, self.y + 50)
            bullets.append(bull)
            bull = Hero_bullet(self.x, self.y, self.x + 100, self.y - 50)
            bullets.append(bull)
            h1_ab = 60
        elif not GG_2:
            bull = Hero_bullet(self.x, self.y, self.target_x, self.target_y, 40, True)
            bullets.append(bull)
            h2_ab = 120
            
    def draw(self):
        if aim or self.tp == 2:
            num = -1
            for num, i in enumerate(npc):
                x, y = i.x, i.y
                if num == 0:
                    self.target_x, self.target_y = x, y
                if sqrt((self.x - x) ** 2 + (self.y - y) ** 2) < sqrt((self.x - self.target_x) ** 2 + (self.y - self.target_y) ** 2):
                    self.target_x, self.target_y = x, y
                self.angle = int(asin((self.target_y - self.y) / sqrt((self.x - self.target_x) ** 2 + (self.y - self.target_y) ** 2)) / pi * 180)
            x, y = boss.x, boss.y
            if sqrt((self.x - x) ** 2 + (self.y - y) ** 2) < sqrt((self.x - self.target_x) ** 2 + (self.y - self.target_y) ** 2) or num == -1:
                self.target_x, self.target_y = x, y
            self.angle = int(asin((self.target_y - self.y) / sqrt((self.x - self.target_x) ** 2 + (self.y - self.target_y) ** 2)) / pi * 180)
        else:
            self.angle = int(asin((self.target_y - self.y) / sqrt((self.x - self.target_x) ** 2 + (self.y - self.target_y) ** 2)) / pi * 180)

        if (len(npc) == 0 and aim and boss.hp == 0) or room != 2:
            self.target_x, self.target_y = self.nx * 1000, self.y
            if self.nx == -1:
                g_l_r = self.typer_l.get_rect(
                    topleft=(self.x, self.y))
                screen.blit(self.typer_l, g_l_r)
                if not ((GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2)):
                    g_l_r = self.curr_weapon[1].get_rect(
                        topleft=(self.x + 22 - (self.tp - 1) * 5, self.y + 42 - (self.tp - 1) * 5))
                    rot_image = pygame.transform.rotate(self.curr_weapon[1], 0)
                    rot_rect = rot_image.get_rect(center=g_l_r.center)
                    rot_image.set_colorkey((24, 29, 35))
                    screen.blit(rot_image, rot_rect)
            else:
                g_l_r = self.typer_r.get_rect(
                    topleft=(self.x, self.y))
                screen.blit(self.typer_r, g_l_r)
                if not ((GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2)):
                    g_l_r = self.curr_weapon[0].get_rect(
                        topleft=(self.x + 22 - (self.tp - 1) * 5, self.y + 42 - (self.tp - 1) * 5))
                    rot_image = pygame.transform.rotate(self.curr_weapon[0], 0)
                    rot_rect = rot_image.get_rect(center=g_l_r.center)
                    rot_image.set_colorkey((24, 29, 35))
                    screen.blit(rot_image, rot_rect)
        else:
            if self.target_x < self.x:
                g_l_r = self.typer_l.get_rect(
                    topleft=(self.x, self.y))
                screen.blit(self.typer_l, g_l_r)
                if not ((GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2)):
                    g_l_r = self.curr_weapon[1].get_rect(
                        topleft=(self.x + 22 - (self.tp - 1) * 5, self.y + 42 - (self.tp - 1) * 5))
                    rot_image = pygame.transform.rotate(self.curr_weapon[1], int(1 * self.angle))
                    rot_rect = rot_image.get_rect(center=g_l_r.center)
                    rot_image.set_colorkey((24, 29, 35))
                    screen.blit(rot_image, rot_rect)
            else:
                g_l_r = self.typer_r.get_rect(
                    topleft=(self.x, self.y))
                screen.blit(self.typer_r, g_l_r)
                if not (GG_1 == True and self.tp == 1) or (GG_2 == True and self.tp == 2):
                    g_l_r = self.curr_weapon[0].get_rect(
                        topleft=(self.x + 22 - (self.tp - 1) * 5, self.y + 42 - (self.tp - 1) * 5))
                    rot_image = pygame.transform.rotate(self.curr_weapon[0], int(-1 * self.angle))
                    rot_rect = rot_image.get_rect(center=g_l_r.center)
                    rot_image.set_colorkey((24, 29, 35))
                    screen.blit(rot_image, rot_rect)

npc_shoot = 0
pygame.init()
pygame.display.set_caption('Soul Knight: PC Edition')
size = width, height = 1200, 900
screen = pygame.display.set_mode(size)
x_pos, y_pos = 0, 0
running = True
x_pos = 0
r = 0
v = 100  
clock = pygame.time.Clock()
fps = 60
hero = Hero(1)
hero_2 = Hero(2)
waves_count = 0
waves = 3
freeze_waves = 0
win = 0
GG_1, GG_2 = False, False
if sasound:
    pygame.mixer.music.load('boss_music.mp3')
    pygame.mixer.music.play()
ccc = 0
hero_2.cd = cd = 0
h1_ab = 60
h2_ab = 120
room = 1
rs = 0
writing = False
f = open('earning.txt').read().split('\n')
hero.hp = int(f[0])
hero_2.hp = int(f[1])
coins = int(f[2])
if hero.hp == 0:
    hero.hp = 1
elif hero_2.hp == 0:
    hero_2.hp = 1
while running:
    if boss.hp <= 0:
        running = False
    if hero.cd > 0:
        hero.cd -= 1
    if hero_2.cd > 0:
        hero_2.cd -= 1
    if h1_ab > 0:
        h1_ab -= 1
    if h2_ab > 0:
        h2_ab -= 1
    if not (GG_1 and GG_2):
        npc_shoot += 1
    screen.fill((0, 0, 0))
    for a in range(1):
        for b in range(1):
            g_l_r = pol.get_rect(
                topleft=(a * 30, b * 30))
            screen.blit(pol, g_l_r)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
        if not (GG_1 and GG_2):
            if event.type == pygame.MOUSEMOTION:
                if not aim:
                    s_x, s_y = event.pos
                    hero.target(s_x - 50, s_y - 50)
            if event.type == pygame.MOUSEBUTTONUP:
                s_x, s_y = event.pos
                hero.shoot(s_x - 50, s_y - 50)
            keys = pygame.key.get_pressed()
            if keys[pygame.K_SPACE] == True:
                hero_2.shoot()
            if keys[pygame.K_LSHIFT] == True and h2_ab == 0:
                hero_2.ability()
            if keys[pygame.K_RSHIFT] == True and h1_ab == 0:
                hero.ability()
            if keys[pygame.K_a] == True and keys[pygame.K_s] == True:
                hero_2.move(-15, 15)
            elif keys[pygame.K_d] == True and keys[pygame.K_s] == True:
                hero_2.move(15, 15)
            elif keys[pygame.K_a] == True and keys[pygame.K_w] == True:
                hero_2.move(-15, -15)
            elif keys[pygame.K_d] == True and keys[pygame.K_w] == True:
                hero_2.move(15, -15)
            elif keys[pygame.K_a] == True:
                hero_2.move(-15, 0)
            elif keys[pygame.K_d] == True:
                hero_2.move(15, 0)
            elif keys[pygame.K_s] == True:
                hero_2.move(0, 15)
            elif keys[pygame.K_w] == True:
                hero_2.move(0, -15)
            if keys[pygame.K_LEFT] == True and keys[pygame.K_DOWN] == True:
                hero.move(-15, 10)
            elif keys[pygame.K_RIGHT] == True and keys[pygame.K_DOWN] == True:
                hero.move(15, 15)
            elif keys[pygame.K_LEFT] == True and keys[pygame.K_UP] == True:
                hero.move(-15, -15)
            elif keys[pygame.K_RIGHT] == True and keys[pygame.K_UP] == True:
                hero.move(15, -15)
            elif keys[pygame.K_LEFT] == True:
                hero.move(-15, 0)
            elif keys[pygame.K_RIGHT] == True:
                hero.move(15, 0)
            elif keys[pygame.K_DOWN] == True:
                hero.move(0, 15)
            elif keys[pygame.K_UP] == True:
                hero.move(0, -15)
            if keys[pygame.K_q] == True:
                aim = not aim
            if keys[pygame.K_RETURN] == True:
                if room == 3:
                    if hero.x in list(range(450, 650)) and hero.y in list(range(200, 500)) and not GG_1:
                        running = False
                    elif hero_2.x in list(range(450, 650)) and hero_2.y in list(range(200, 500)) and not GG_2:
                        running = False
                elif room == 1:
                    if hero.x in list(range(0, 200)) and hero.y in list(range(0, 250)) and not GG_1:
                        if coins >= 15:
                            coins -= 15
                            GG_1 = False
                            GG_2 = False
                            hero.hp = 10
                            hero_2.hp = 10
                        else:
                            t = n.render('Not enough coins!', True, (255, 0, 0))
                            screen.blit(t, (300, 550))
                    elif hero_2.x in list(range(0, 200)) and hero_2.y in list(range(0, 250)) and not GG_2:
                        if coins >= 15:
                            coins -= 15
                            GG_1 = False
                            GG_2 = False
                            hero.hp = 10
                            hero_2.hp = 10
                        else:
                            t = n.render('Not enough coins!', True, (255, 0, 0))
                            screen.blit(t, (300, 550))

    
    g_l_r = wall_hor.get_rect(
            topleft=(0, 0))
    screen.blit(wall_hor, g_l_r)
    g_l_r2 = wall_ver.get_rect(
            topleft=(0, 3))
    screen.blit(wall_ver, g_l_r2)
    g_l_r3 = wall_ver.get_rect(
            topleft=(1165, 3))
    screen.blit(wall_ver, g_l_r3)
    g_l_r1 = wall_hor.get_rect(
            topleft=(0, 747))
    screen.blit(wall_hor, g_l_r1)
    if room == 2:
        g_l_r1 = obs.get_rect(
                topleft=(350, 320))
        screen.blit(obs, g_l_r1)
    if room == 1:
        g_l_r1 = trade.get_rect(
                topleft=(35, 0))
        screen.blit(trade, g_l_r1)
    if not(len(npc) == 0 and waves_count == 3) and room == 2:
        g_l_r1 = walkthrough.get_rect(
                topleft=(350, -11))
        screen.blit(walkthrough, g_l_r1)
        g_l_r1 = walkthrough.get_rect(
                topleft=(350, 738))
        screen.blit(walkthrough, g_l_r1)
    else:
        if room != 3:
            pygame.draw.rect(screen, (125, 96, 48), (350, 0, 465, 55))
        if room != 1:
            pygame.draw.rect(screen, (125, 96, 48), (350, 740, 465, 60))
    if room == 2:
        for i in courpses:
            g_l_r2 = courpse.get_rect(
                topleft=(i[0], i[1]))
            screen.blit(courpse, g_l_r2)
    if room == 3:
        g_l_r2 = portal.get_rect(
            topleft=(500, 300))
        screen.blit(portal, g_l_r2)
    if room == 2:
        for num, i in enumerate(bombs):
            if i.draw() is True:
                del bombs[num]        
    hero.draw()
    hero_2.draw()
    pygame.draw.rect(screen, (0, 0, 0), (0, 800, 1200, 100))
    g_l_r1 = hp_bar.get_rect(
            topleft=(100, 810))
    screen.blit(hp_bar, g_l_r1)
    g_l_r1 = hero_r.get_rect(
            topleft=(10, 810))
    screen.blit(hero_r, g_l_r1)
    g_l_r1 = hp_bar.get_rect(
            topleft=(600, 810))
    screen.blit(hp_bar, g_l_r1)
    g_l_r1 = other_hero_r.get_rect(
            topleft=(510, 810))
    screen.blit(other_hero_r, g_l_r1)
    g_l_r1 = coin.get_rect(
            topleft=(1000, 810))
    screen.blit(coin, g_l_r1)
    n = pygame.font.Font(None, 80)
    t = n.render(str(coins), True, (255, 255, 0))
    screen.blit(t, (1080, 820))
    pygame.draw.rect(screen, (255, 0, 0), (174, 830, int(230 * (hero.hp / (hero.total + hp_boost))), 34))
    pygame.draw.rect(screen, (255, 0, 0), (674, 830, int(230 * (hero_2.hp / (hero.total + hp_boost))), 34))
    pygame.draw.rect(screen, (0, 255, 0), (420, 820, 30, 60 - int(h1_ab)))
    pygame.draw.rect(screen, (0, 255, 0), (920, 820, 30, 60 - int(h2_ab / 2)))
    if room == 2:
        for num, x in enumerate(npc):
            x.move(x.hp, (GG_1 and GG_2))
            if not (GG_1 and GG_2):
                if x.hp <= 0:
                    del npc[num]
                    coins += 1
                    print(coins)
                if npc_shoot % x.cd  == 0:
                    x.attack()
        x = boss
        x.move(x.hp, (GG_1 and GG_2))
        if not (GG_1 and GG_2):
            if x.hp <= 0:
                coins += 1
                print(coins)
            if npc_shoot % x.cd  == 0:
                x.attack()
    for num, i in enumerate(bullets):
        if i.draw() is True:
            del bullets[num]
    if room == 2:
        for num, i in enumerate(npc_bullets):
            if i.draw() is True:
                del npc_bullets[num]
    if room == 2:
        for num, i in enumerate(boss_bullets):
            if i.draw() is True:
                del boss_bullets[num]
    
    
    if waves_count == waves and len(npc) == 0 and win >= 0 and win < 60:
        win += 1
        n = pygame.font.Font(None, 120)
        t = n.render('ROOM COMPLETED!', True, (0, 255, 0))
        screen.blit(t, (200, 420))
    if writing:
        n = pygame.font.Font(None, 120)
        t = n.render(f'Wave {waves_count + 1}: ', True, (255, 0, 0))
        screen.blit(t, (450, 400))
    if GG_1 and GG_2:
        hero_2.typer_l, hero_2.typer_r, hero.typer_l, hero.typer_r = hc, hc, hc, hc
        n = pygame.font.Font(None, 240)
        t = n.render(f'YOU LOSE !!!', True, (255, 50, 50))
        screen.blit(t, (80, 300))
        if ccc == 0:
            if sasound:
                pygame.mixer.music.load('grobik.mp3')
                pygame.mixer.music.play()
            ccc += 1
    if GG_1:
        hero.typer_l, hero.typer_r = hc, hc
    elif not GG_1:
        hero.typer_l, hero.typer_r = hero_l, hero_r
    if GG_2:
        hero_2.typer_l, hero_2.typer_r = hc, hc
    elif not GG_2:
        hero_2.typer_l, hero_2.typer_r = other_hero_l, other_hero_r
    if room == 1 and hero.x in list(range(0, 200)) and hero.y in list(range(0, 250)):
        n = pygame.font.Font(None, 120)
        t = n.render('Press ENTER to', True, (0, 255, 0))
        screen.blit(t, (200, 220))
        t = n.render('Retire HP for 15 coins.', True, (0, 255, 0))
        screen.blit(t, (200, 420))
    elif room == 1 and hero_2.x in list(range(0, 200)) and hero_2.y in list(range(0, 250)):
        n = pygame.font.Font(None, 120)
        t = n.render('Press ENTER to', True, (0, 255, 0))
        screen.blit(t, (200, 220))
        t = n.render('Retire HP for 15 coins.', True, (0, 255, 0))
        screen.blit(t, (200, 420))
    if ((not GG_1 or not GG_2) and waves_count == waves and len(npc) == 0 and room == 2) or room == 1 or (len(courpses) > 0 and waves_count == 3 and len(npc) == 0 and room == 2):
        if hero.x in list(range(350, 350 + 465)) and hero.hp > 0 and hero.y in list(range(0, 65)):
            room += 1
            hero.x = 350
            hero.y = 600
            hero_2.x = 700
            hero_2.y = 600
        if hero_2.x in list(range(350, 350 + 465)) and hero_2.hp > 0 and hero_2.y in list(range(0, 65)):
            room += 1
            hero.x = 350
            hero.y = 600
            hero_2.x = 700
            hero_2.y = 600
    if ((not GG_1 or not GG_2) and waves_count == waves and len(npc) == 0 and room == 2) or room == 3 or (len(courpses) > 0 and waves_count == 3 and len(npc) == 0 and room == 2):
        if hero.x in list(range(350, 350 + 465)) and hero.hp > 0 and hero.y in list(range(620, 800)):
            room -= 1
            hero.x = 350
            hero.y = 200
            hero_2.x = 700
            hero_2.y = 200
        if hero_2.x in list(range(350, 350 + 465)) and hero_2.hp > 0 and hero_2.y in list(range(620, 800)):
            room -= 1
            hero.x = 350
            hero.y = 200
            hero_2.x = 700
            hero_2.y = 200
    if room == 3 and hero_2.x in list(range(450, 650)) and hero_2.y in list(range(200, 500)):
        n = pygame.font.Font(None, 120)
        t = n.render('Press ENTER to', True, (0, 255, 0))
        screen.blit(t, (250, 220))
        t = n.render('teleport foreward.', True, (0, 255, 0))
        screen.blit(t, (250, 520))
    if room == 3 and hero.x in list(range(450, 650)) and hero.y in list(range(200, 500)):
        n = pygame.font.Font(None, 120)
        t = n.render('Press ENTER to', True, (0, 255, 0))
        screen.blit(t, (250, 220))
        t = n.render('teleport foreward.', True, (0, 255, 0))
        screen.blit(t, (250, 520))
    if rs >= 0 and rs < 60 and room == 1:
        rs += 1
        n = pygame.font.Font(None, 120)
        t = n.render('LEVEL 1-5!', True, (0, 0, 255))
        screen.blit(t, (350, 420))
        
    clock.tick(fps)
    pygame.display.flip()

try:
    with open("earning.txt", 'w'):
        pass
except IOError:
    pass
w = open("earning.txt", 'w')
w.write(str(hero.hp) + '\n')
w.write(str(hero_2.hp) + '\n')
w.write(str(coins) + '\n')
w.close()

runner = True

while runner:
    screen.fill((0, 0, 0))
    g_l_r = titry.get_rect(
        topleft=(0, 0))
    screen.blit(titry, g_l_r)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
        if event.type == pygame.MOUSEBUTTONUP:
            s_x, s_y = event.pos
            if int(s_x) in list(range(250, 850)) and int(s_y) in list(range(590, 790)):
                runner = False
    pygame.display.flip()
    
import finish