# Fartman
import pygame
import sys
import os
import random
import re
import math
import time

width = 1920
height = 1080
pygame.mixer.init()

white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
green = (0,255,0)
blue = (0, 0, 255)
yellow = (255, 255, 0)
cyan = (0, 255, 255)

all_sprites = []
gravity_sprites = []
floors = []
enemy_sprites = []
box_sprites = pygame.sprite.Group()

box_sprites2 = []
powerup_sprites = []
mm_sprites = []
projectile_sprites = []
no_move_enemy_sprites = []

scroll_sprites = []
edit_temp_sprites = []
rotating_orbs_sprites = []
portapotty_sprites = []

fartman_imgs = []
level_1_load = True
level_2_load = False

global gravity
gravity = 1.8
salami = False

# MAKE SOUNDTRACK
# USE CENTERX TO HELP HITBOXES IF THERE ARE ISSUES

if __name__ == '__main__':

    pygame.init()
    window = pygame.display.set_mode((width, height))
    pygame.display.set_caption('Fartman')
    running = True
    clock = pygame.time.Clock()

    main_menu_img = pygame.image.load('fartman.png').convert()
    new_img = pygame.image.load('new.png').convert()
    continue_img = pygame.image.load('continue.png').convert()
    quit_img = pygame.image.load('quit.png').convert()

    new_hl_img = pygame.image.load('new_hl.png').convert()
    continue_hl_img = pygame.image.load('continue_hl.png').convert()
    quit_hl_img = pygame.image.load('quit_hl.png').convert()

    class Main_Menu(pygame.sprite.Sprite):
        def __init__(self):
            pygame.sprite.Sprite.__init__(self)
            self.image = main_menu_img
            self.rect = self.image.get_rect()
            self.showing = True

            self.new = pygame.sprite.Sprite()
            self.new.image = new_img
            self.new.og_image = new_img
            self.new.highlighted = False
            self.new.highlighted_img = new_hl_img
            self.new.rect = self.new.image.get_rect()
            self.new.rect.centerx, self.new.rect.centery = width / 2, 350
            self.new.coords = (width / 2, 350)

            self.continue_ = pygame.sprite.Sprite()
            self.continue_.image = continue_img
            self.continue_.og_image = continue_img
            self.continue_.highlighted = False
            self.continue_.highlighted_img = continue_hl_img
            self.continue_.rect = self.continue_.image.get_rect()
            self.continue_.rect.centerx, self.continue_.rect.centery = width / 2, 550
            self.continue_.coords = (width / 2, 550)

            self.quit = pygame.sprite.Sprite()
            self.quit.image = quit_img
            self.quit.og_image = quit_img
            self.quit.highlighted = False
            self.quit.highlighted_img = quit_hl_img
            self.quit.rect = self.quit.image.get_rect()
            self.quit.rect.centerx, self.quit.rect.centery = width / 2, 750
            self.quit.coords = (width / 2, 750)

            mm_sprites.extend([self.new, self.continue_, self.quit])

    main_menu = Main_Menu()
    mm_sprites.insert(0,main_menu)

    fartman_standing_1_img = pygame.image.load('default_Fartman_Standing_1.png').convert()

    fartman_running_right_1_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_1.png').convert(), (int(240/4), int(442/4)))
    fartman_running_right_2_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_2.png').convert(), (int(238/4), int(426/4)))
    fartman_running_right_3_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_3.png').convert(), (int(169/4), int(428/4)))
    fartman_running_right_4_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_4.png').convert(), (int(196/4), int(432/4)))
    fartman_running_right_5_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_5.png').convert(), (int(258/4), int(444/4)))
    fartman_running_right_6_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_6.png').convert(), (int(271/4), int(447/4)))
    fartman_running_right_7_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_7.png').convert(), (int(174/4), int(428/4)))
    fartman_running_right_8_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningRight_8.png').convert(), (int(183/4), int(429/4)))

    fartman_running_left_1_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_1.png').convert(), (int(240/4), int(442/4)))
    fartman_running_left_2_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_2.png').convert(), (int(238/4), int(426/4)))
    fartman_running_left_3_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_3.png').convert(), (int(169/4), int(428/4)))
    fartman_running_left_4_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_4.png').convert(), (int(196/4), int(432/4)))
    fartman_running_left_5_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_5.png').convert(), (int(258/4), int(444/4)))
    fartman_running_left_6_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_6.png').convert(), (int(271/4), int(447/4)))
    fartman_running_left_7_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_7.png').convert(), (int(174/4), int(428/4)))
    fartman_running_left_8_img = pygame.transform.scale(pygame.image.load('default_NewFartman_runningLeft_8.png').convert(), (int(183/4), int(429/4)))

    fartman_imgs.extend([fartman_running_right_1_img, fartman_running_right_2_img, fartman_running_right_3_img])
    fartman_imgs.extend([fartman_running_left_1_img, fartman_running_left_2_img, fartman_running_left_3_img])
    class Fartman(pygame.sprite.Sprite):
        def __init__(self):
            pygame.sprite.Sprite.__init__(self)

            self.image = pygame.transform.scale(fartman_standing_1_img, (52, 106))
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.centerx, self.rect.centery = width / 2, height / 2
            self.area = range(self.rect.left, self.rect.right)
            self.area_y = range(self.rect.top, self.rect.bottom)

            self.og_gravity = 1.8
            self.gravity = 1.8
            self.touching_floor = False
            self.jumping = False
            self.jump_cd = pygame.time.get_ticks() # jump cooldown
            self.jump_initial_boost = True
            self.jump_time = 0
            self.jump_time1 = pygame.time.get_ticks()
            self.jump_time2 = pygame.time.get_ticks()

            self.hit_cd = pygame.time.get_ticks()
            self.hp = 1 # every 1 hp is an hp grade (i.e. big, fire, whatever the nigger mario does
            self.gravity_reset = False
            self.what_touching = None
            self.gravity_check = False
            self.gravity_counter = 0

            self.no_right = False
            self.no_left = False
            self.no_right_counter = 0
            self.no_left_counter = 0
            self.direction = None
            self.level = 1
            self.enter_portapotty = False
            self.level_end = False

            self.level_1_load = True
            self.level_2_load = False

            self.coords = (self.rect.x, self.rect.y)
            self.running_right_counter = 0
            self.running_left_counter = 0
            self.override_no_right = False
            self.override_no_left = False
            self.load = False

            self.powerup = 'None' # 'None' by default
            self.dead = False
            self.poop_throw_cd = pygame.time.get_ticks()
            self.level_1_end = False
            self.platform_make_powerup_cd = pygame.time.get_ticks()
            self.platforms = []
            self.scroll_speed = 5
            self.fast_cd = pygame.time.get_ticks()

            self.rotating_orbs_cd = True
            self.fuckingkms = pygame.sprite.Sprite()
            self.fuckingkms.image = pygame.Surface((1,1,))
            self.fuckingkms.rect = self.fuckingkms.image.get_rect()
            self.fuckingkms.rect.x = 0

            self.break_box_cd = pygame.time.get_ticks()
            self.break_box_cd2 = pygame.time.get_ticks()
            self.touching_box = False
            self.score = 0
            self.lives = 3
            self.ogx, self.ogy = self.rect.x, self.rect.y
            self.dont_scroll = False
            self.left_side_block = []

            self.invisible_detection = pygame.sprite.Sprite()
            self.invisible_detection.image = pygame.Surface((self.rect.width - 12, 5))
            self.invisible_detection.image.fill(red)
            self.invisible_detection.image.set_colorkey(white)
            self.invisible_detection.rect = self.invisible_detection.image.get_rect()
            self.invisible_detection.rect.centerx, self.invisible_detection.top = self.rect.centerx, self.rect.top - 1

            self.editing_mode = False
            self.edit_ground_cd = pygame.time.get_ticks()
            self.edit_box_cd = pygame.time.get_ticks()
            self.edit_assignment_list = []
            self.edit_sprite_assignment_list = []
            self.edit_compile_timer = pygame.time.get_ticks()

            self.edit_box_loot_cd = pygame.time.get_ticks()
            self.edit_Poopyhead_cd = pygame.time.get_ticks()
            self.edit_PoopyBird_cd = pygame.time.get_ticks()
            self.edit_Popout_Sword_cd = pygame.time.get_ticks()
            self.editTF = True
            self.edit_cannon_cd = pygame.time.get_ticks()

            self.edit_level = 1
            self.remove_for_edit = False
            self.edit_portapotty_cd = pygame.time.get_ticks()
            self.edit1 = True
            self.edit_load = False

            for i in range(0,1):
                i = pygame.sprite.Sprite()
                i.image = pygame.Surface((5, 1200))
                i.image.fill(white)
                i.image.set_colorkey(white)
                i.rect = i.image.get_rect()
                i.rect.right, i.rect.bottom = 1, height
                self.left_side_block.append(i)

        def touching(self):
            try:
                for floor in floors:
                    if floor.no_left:
                        self.no_left = True
                    elif floor.no_right:
                        self.no_right = True
            except:
                pass

            height = self.rect.bottom - self.rect.y
            width = self.rect.right - self.rect.x
            self.break_box_cd2 = pygame.time.get_ticks()
            if self.touching_floor:
                self.jump_time = 0

            self.invisible_detection.image = pygame.Surface((self.rect.width - 24, 1))
            self.invisible_detection.image.fill(white)
            self.invisible_detection.image.set_colorkey(white)
            self.invisible_detection.rect.x, self.invisible_detection.top = self.rect.x + 60, self.rect.top - 1
            for floor in floors:
                if floor.legit:
                    if self.rect.right in range(floor.rect.left, floor.rect.right) or self.rect.left in range(floor.rect.left, floor.rect.right):
                        if self.rect.bottom in range(floor.rect.y - 2, floor.rect.y + 30):
                            self.touching_floor = True
                            self.jumping = False
                            self.jump_initial_boost = True
                            self.what_touching = floor.rect.top
                            self.rect.bottom = self.what_touching
                            self.jump_time = 0
                            self.gravity = 1.8
                            try:
                                floor.onTop = True
                            except:
                                pass
                            self.gravity_reset = True
                        else:
                            self.gravity_reset = False
                            self.toucing_floor = False
                            try:
                                floor.onTop = False
                            except:
                                pass

        def movement(self): # Add velocity later? i.e. to turn from one direction to the other it takes longer? (it slides)
            keyState = pygame.key.get_pressed()
            self.jump_time = self.jump_time2 - self.jump_time1
            new_jump_cd = pygame.time.get_ticks()
            upwards = 6.5
            self.area = range(self.rect.left, self.rect.right)

            self.cords = (self.rect.x, self.rect.y)
            self.area_y = range(self.rect.top, self.rect.bottom)
            scroll = True
            self.invisible_detection.rect.x, self.invisible_detection.rect.x = self.rect.x, self.rect.y - 5

            for sprite in self.left_side_block:
                if self.rect.colliderect(sprite.rect):
                    self.no_left = True

            for sprite in floors:
                if floors.index(sprite) == 0:
                    if sprite.rect.left in range(-5,5):
                        self.dont_scroll = True
                        self.rect.x - 1
                    else:
                        self.dont_scroll = False

            if self.rect.x >= width/2:
                self.dont_scroll = False

            if len(box_sprites) <= 1:
                self.touching_box = False

            if keyState[pygame.K_p]:
                self.editing_mode = True

            if self.override_no_right:
                self.no_right = True
            if self.override_no_left:
                self.no_left = True
            if keyState[pygame.K_d]:
                if not self.no_right:
                    if not self.dont_scroll:
                        self.fuckingkms.rect.x -= self.scroll_speed
                        for sprite in scroll_sprites:
                            sprite.rect.x -= self.scroll_speed
                        for sprite in loopable_bgs:
                            sprite.rect.x -= 1
                    else:
                        self.rect.x += 5
                    self.direction = 'right'
                    if self.running_right_counter <= 11:
                        self.image =  fartman_running_right_1_img
                        self.image.set_colorkey(white)
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 22:
                        self.image =  fartman_running_right_2_img
                        self.image.set_colorkey(white)
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 33:
                        self.image =  fartman_running_right_3_img
                        self.image.set_colorkey(white)
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 44:
                        self.image =  fartman_running_right_4_img
                        self.image.set_colorkey(white)
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 55:
                        self.image = fartman_running_right_5_img
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 66:
                        self.image = fartman_running_right_6_img
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 77:
                        self.image = fartman_running_right_7_img
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 88:
                        self.image = fartman_running_right_8_img
                        self.running_right_counter += 1
                    elif self.running_right_counter <= 99:
                        self.running_right_counter = 0

            self.image.set_colorkey(white)
            if keyState[pygame.K_a]:
                if not self.no_left:
                    if not self.dont_scroll:
                        self.fuckingkms.rect.x += self.scroll_speed
                        for sprite in scroll_sprites:
                            sprite.rect.x += self.scroll_speed
                        for sprite in loopable_bgs:
                            sprite.rect.x += 1
                    else:
                        self.rect.x -= 5
                    self.direction = 'left'
                    if self.running_left_counter <= 11:
                        self.image =  fartman_running_left_1_img
                        self.image.set_colorkey(white)
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 22:
                        self.image =  fartman_running_left_2_img
                        self.image.set_colorkey(white)
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 33:
                        self.image =  fartman_running_left_3_img
                        self.image.set_colorkey(white)
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 44:
                        self.image =  fartman_running_left_4_img
                        self.image.set_colorkey(white)
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 55:
                        self.image = fartman_running_left_5_img
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 66:
                        self.image = fartman_running_left_6_img
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 77:
                        self.image = fartman_running_left_7_img
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 88:
                        self.image = fartman_running_left_8_img
                        self.running_left_counter += 1
                    elif self.running_left_counter <= 99:
                        self.running_left_counter = 0
                    self.image.set_colorkey(white)

            if keyState[pygame.K_SPACE]:
                if self.touching_floor or self.touching_box:
                    if new_jump_cd - self.jump_cd >= 500:
                        if not self.jumping:
                            self.gravity = self.og_gravity
                            self.jump_cd = new_jump_cd
                            self.jumping = True
                            self.jump_time1 = pygame.time.get_ticks()
                            jump_time = pygame.time.get_ticks()

            if self.jumping:
                self.jump_time2 = pygame.time.get_ticks() # Holy fuck this is so spaghetti kill me
                self.touching_floor = False
                if self.jump_initial_boost:
                    self.rect.bottom -= 8
                self.jump_initial_boost = False
                self.rect.y -= upwards
                if self.touching_box:
                    if len(box_sprites) <= 1:
                        self.rect.y += self.gravity
            if not self.jumping:
                self.jump_time = 0

            for box in box_sprites:
                if not self.rect.right in range(box.rect.left, box.rect.right+5) or not self.rect.left in range(box.rect.left, box.rect.right+5) and not self.rect.bottom in range(box.rect.y - 2, box.rect.y + 2):
                    if self.rect.colliderect(box.rect):
                        self.break_box_cd = pygame.time.get_ticks()
                        if self.direction == 'right':
                            self.no_right = True
                            self.no_right_counter = 0
                            self.no_left = False
                        elif self.direction == 'left':
                            self.no_left = True
                            self.no_left_counter = 0
                            self.no_right = False
                    else:
                        self.no_right_counter += 1
                        self.no_left_counter += 1
                        if self.no_right_counter >= len(box_sprites):
                            self.no_right = False
                        if self.no_left_counter >= len(box_sprites):
                            self.no_left = False
                    if self.gravity_counter >= len(box_sprites):
                        self.touching_floor = False
                        self.gravity_reset = False
                        if self.gravity < self.og_gravity:
                            self.gravity = 1.8

                if self.rect.right in range(box.rect.left, box.rect.right+5) or self.rect.left in range(box.rect.left, box.rect.right+5):
                    if self.rect.bottom in range(box.rect.y - 2, box.rect.y + 10):
                        self.touching_floor = True
                        self.jumping = False
                        self.touching_box = True
                        self.what_touching = box.rect.top
                        self.rect.bottom = self.what_touching
                        self.gravity_check = True
                        self.gravity = 0
                        self.jump_time = 0
                        self.gravity_reset = True
                        self.og_gravity = 0
                        self.gravity_counter = 0
                        if len(box_sprites) <= 1:
                            self.gravity = 1.8
                    else:
                        if self.gravity_counter >= len(box_sprites):
                            self.touching_floor = False
                            self.gravity_reset = False
                            if self.gravity < self.og_gravity:
                                self.gravity = 1.8
                else:
                    if self.gravity_counter >= len(box_sprites):
                        if self.gravity <= self.og_gravity:
                            if self.gravity_counter >= len(box_sprites):
                                self.gravity = 1.8

                    self.gravity_reset = False
                    self.touching_floor = False # Honestly can't believe how spaghetti it is lmfao
                    self.gravity_counter += 1

                for i in self.area:
                    if i in range(box.rect.left-5, box.rect.right+5):
                        if self.rect.bottom in range(box.rect.y - 2, box.rect.y + 2):
                            self.touching_floor = True
                            self.jumping = False
                            self.what_touching = box.rect.top
                            self.gravity_reset = True
                            self.og_gravity = 0
                        else:
                            if self.gravity_counter >= len(box_sprites):
                                self.touching_floor = False
                                self.gravity_reset = False
                    else:
                        if self.gravity_counter >= len(box_sprites):
                            self.gravity_reset = False
                            self.touching_floor = False

            if self.gravity_reset:
                self.rect.bottom = self.what_touching
                self.touching_floor = True
                self.jump_initial_boost = True
                self.jump_time = 0
                self.gravity = 1.8

            try:
                for floor in floors:
                    if floor.no_left:
                        self.no_left = True
                    elif floor.no_right:
                        self.no_right = True
            except:
                pass

        def stomping_enemies(self):
            height = self.rect.bottom - self.rect.y
            width = self.rect.right - self.rect.x
            damage_cd = pygame.time.get_ticks()
            if self.hp <= 0:
                self.dead = True
            if self.dead:
                self.lives -= 1
                self.hp = 1
                self.rect.x, self.rect.y = self.ogx, self.ogy
                for sprite in scroll_sprites:
                    sprite.reset = True
                for sprite in portapotty_sprites:
                    sprite.reset = True
                for sprite in box_sprites:
                    sprite.reset = True
                self.powerup = 'None'
                self.dead = False
                 # ADD GAME OVER

            try:
                for enemy in enemy_sprites:
                    if self.rect.bottom in range(enemy.rect.top - 8, enemy.rect.top + 15):
                        if self.rect.left + width in range(enemy.rect.left -3, enemy.rect.right +3) or self.rect.right - width in range(enemy.rect.left-3, enemy.rect.right+3):
                            if self.jump_time >= 300 and enemy.killable:
                                print('Killed enemy sprite.')
                                enemy.alive = False
                                enemy.kill()
                                enemy_sprites.remove(enemy)
                                self.score += 100
                                self.gravity = 5.2
                        for i in self.area:
                            if i in range(enemy.rect.left-3, enemy.rect.right+3):
                                if self.jump_time >= 300:
                                    enemy.alive = False
                                    enemy.kill()
                                    enemy_sprites.remove(enemy)

                    if self.rect.bottom > enemy.rect.top:
                        if self.rect.left in range(enemy.rect.left, enemy.rect.right) or self.rect.right in range(enemy.rect.left, enemy.rect.right):
                            if damage_cd - self.hit_cd >= 1000 and self.rect.colliderect(enemy):
                                self.hp -= 1
                                self.hit_cd = damage_cd
                                print('Hit by enemy sprite')
            except:
                pass

            if self.rect.top >= 1080: # height of screen
                self.dead = True

        def break_boxes(self):
            height = self.rect.bottom - self.rect.y
            width = self.rect.right - self.rect.x
            for box in box_sprites:
                if self.break_box_cd2 - self.break_box_cd >= 100:
                    if box.type == 'no loot':
                        if self.rect.top in range(box.rect.bottom - 3, box.rect.bottom + 3):
                            if self.rect.left + width in range(box.rect.left -3, box.rect.right +3) or self.rect.right - width in range(box.rect.left-3, box.rect.right+3):
                                print('scra boom!')
                                if self.jump_time <= 1000:
                                    print('Empty box hit')
                                    # if size > 1: box break, otherwise box doesn't break
                                    if not box.broken:
                                        box.broken = True
                                    self.jumping = False

                            for i in self.area:
                                if i in range(box.rect.left -3, box.rect.right +3):
                                    if self.jump_time <= 1000:
                                        if not box.broken:
                                            print('Empty box hit')
                                            box.broken = True
                                        self.jumping = False
                    elif box.type == 'loot':
                        if self.rect.top in range(box.rect.bottom - 4, box.rect.bottom + 2):
                            if self.rect.left + width in range(box.rect.left -3, box.rect.right +3) or self.rect.right - width in range(box.rect.left-3, box.rect.right+3):
                                if self.jump_time <= 1000:
                                    if not box.broken:
                                        print('Loot box hit')
                                        box.broken = True
                                    self.jumping = False
                                    box.releasing = True
                            for i in self.area:
                                if i in range(box.rect.left -3, box.rect.right +3):
                                    if self.jump_time <= 1000:
                                        if not box.broken:
                                            print('Loot box hit')
                                            box.broken = True
                                        self.jumping = False
                                        box.releasing = True

        def powerups(self):
            mx, my = pygame.mouse.get_pos()
            timer = pygame.time.get_ticks()
            for powerup in powerup_sprites:
                if self.rect.colliderect(powerup):
                    if powerup.type == 'Big' and self.powerup == 'None':
                        self.hp += 1
                        self.powerup = 'Big'
                        self.score += 1000
                        # CHANGE IMAGE
                        print('Gained powerup: Big')
                        powerup_sprites.remove(powerup)
                        for image in fartman_imgs:
                            width, height = image.get_size()
                            print('doubling')
                            image = pygame.transform.scale(image, (width*2, height*2))
                    elif powerup.type == 'poop' and self.powerup == 'None':
                        self.hp += 2
                        self.powerup = 'poop'
                        self.score += 1000
                        print('Gained powerup: poop')
                        # CHANGE IMAGE i.e. self.poop_images = True. In the animations, make it so that the regular animations are only there
                        # if the poop animations aren't (i.e. if the powerup is not poop) or some other powerup
                    elif powerup.type == 'poop' and self.powerup == 'Big':
                        self.hp += 1
                        print('Gained powerup: poop')
                        self.powerup = 'poop'
                        self.score += 1000
                    elif powerup.type == 'Big' and self.powerup != 'None':
                        self.score += 1000
                        powerup_sprites.remove(powerup)
                        print("Couldn't gain powerup as current powerup exceeds its power")
                    elif powerup.type == 'platform' and self.powerup == 'None':
                        self.hp += 1
                        self.powerup = 'platform'
                        self.score += 1000
                        powerup_sprites.remove(powerup)
                        print('Gained powerup: make platforms')
                    else:
                        self.score += 1000
                        powerup_sprites.remove(powerup)

            if self.powerup == 'poop':
                keyState = pygame.key.get_pressed()
                if keyState[pygame.K_f] and timer - self.poop_throw_cd >= 500:
                    self.poop_throw_cd = timer
                    for i in range(0,1):
                        i = Poop_Throw_Sprite(self.direction)
                        projectile_sprites.append(i)
                        scroll_sprites.append(i)

            elif self.powerup == 'platform':
                keyState = pygame.key.get_pressed()
                if keyState[pygame.K_f] and timer - self.platform_make_powerup_cd >= 500:
                    self.platform_make_powerup_cd = timer
                    for i in range(0,1):
                        i = Platform(mx, my)
                        scroll_sprites.append(i)
                        floors.append(i)
                        self.platforms.append(i)
                    if len(self.platforms) >= 3:
                        self.powerup = 'Big'

            elif self.powerup == 'fast':
                self.scroll_speed = 10
                if timer - self.fast_cd >= 10000:
                    self.powerup = 'Big'
                    self.fast_cd = timer

            elif self.powerup == 'rotating orbs':
                if self.rotating_orbs_cd:
                    for i in range(0,1):
                        i = Rotating_Orbs()
                        rotating_orbs_sprites.append(i)
                    self.rotating_orbs_cd = False

        def end_level(self):
            if self.enter_portapotty:
                self.level_end = True # ADD A COUNTER SO IT DOESN'T SKIP LIKE 20 LEVELS

            if self.level_end:
                try:
                    for floor in floors:
                        if floor.level == self.level:
                            floors.remove(floor)
                        try:
                            for i in floor.under_floor_sprites:
                                floor.under_floor_sprites.remove(i)
                        except:
                            pass
                    for box in box_sprites:
                        if box.level == self.level:
                            box_sprites.remove(box)
                    for enemy in enemy_sprites:
                        if enemy.level == self.level:
                            enemy_sprites.remove(enemy)
                    for sprite in portapotty_sprites:
                        if sprite.level == self.level:
                            portapotty_sprites.remove(sprite)
                    for sprite in gravity_sprites:
                        if sprite != self:
                            gravity_sprites.remove(sprite)
                    for sprite in box_sprites2:
                        box_sprites.remove(sprite)
                    for sprite in no_move_enemy_sprites:
                        no_move_enemy_sprites.remove(sprite)
                    for sprite in scroll_sprites:
                        scroll_sprites.remove(sprite)
                except:
                    pass

                print(self.level)
                if self.level + 1 == 2:
                    self.level_1_load = False
                    self.level_2_load = True
                self.level_end = False
                self.level += 1
                self.enter_portapotty = False
                self.load = True
                salami = True

        def Editing_Mode(self):
            keyState = pygame.key.get_pressed()
            mx, my = pygame.mouse.get_pos()
            timer = pygame.time.get_ticks()
            self.gravity = 0
            self.jumping = False
            self.hp = 1000
            if self.editTF:
                self.edit_level = int(input('What level is this going to be? '))
                self.remove_for_edit = input('Would you like to delete all objects on screen to make the level? ')
                self.editTF = False
            if self.remove_for_edit == 'yes':
                for floor in floors:
                    if floor.level == self.level:
                        floors.remove(floor)
                    try:
                        for i in floor.under_floor_sprites:
                            floor.under_floor_sprites.remove(i)
                            floors.remove(i)
                    except:
                        pass

                for box in box_sprites:
                    if box.level == self.level:
                        box_sprites.remove(box)
                for enemy in enemy_sprites:
                    if enemy.level == self.level:
                        enemy_sprites.remove(enemy)
                for sprite in portapotty_sprites:
                    portapotty_sprites.remove(sprite)
                for sprite in scroll_sprites:
                    scroll_sprites.remove(sprite)
                for sprite in gravity_sprites:
                    gravity_sprites.remove(sprite)
                for sprite in box_sprites2:
                    box_sprites2.remove(sprite)
                for sprite in no_move_enemy_sprites:
                    no_move_enemy_sprites.remove(sprite)
                self.remove_for_edit = 'kys'

            if self.edit_level == 1:
                if self.edit1:
                    if not os.stat('level_1.txt').st_size == 0:
                        continue_ = input('That level already has some edits. Would you like to make more, or delete the level and start anew? (more/delete)')
                        if continue_ == 'more':
                            self.edit_level_one = True
                            self.level_1_load = True
                            self.load = True
                            self.edit_load=True
                            salami = True

                    self.edit1 = False
            elif self.edit_level == 2:
                if self.edit2:
                    if not os.stat('level_2.txt').st_size == 0:
                        continue_ = input('Thta level already has some edits. Would you like to make more, or delete the level and start anew? (more/delete')
                        if continue_ == 'more':
                            self.edit_level_two = True
                            self.level_2_load = True
                            self.load = True
                            self.edit_load = True
                            salami = True

            if keyState[pygame.K_w] or keyState[pygame.K_SPACE]:
                self.rect.y -= 5
            elif keyState[pygame.K_s]:
                self.rect.y += 5

            if keyState[pygame.K_g]:
                if timer - self.edit_ground_cd >= 500:
                    # change here to fuck with the levels for the editor
                    a = 'G '+str(mx-self.fuckingkms.rect.x) +' '+str(my)+' '+str(self.edit_level)+' floors'
                    b = Ground(mx, my, self.edit_level, floors)
                    print(a)
                    self.edit_ground_cd = timer
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    floors.append(b)
                    self.edit_sprite_assignment_list.append(b)

            if keyState[pygame.K_b]:
                if timer - self.edit_box_cd >= 1000:
                    a = 'B '+str(mx - self.fuckingkms.rect.x)+' '+str(my)+' no loot ' +str(self.edit_level)
                    b = Box(mx, my, 'no loot', self.edit_level)
                    print(a)
                    self.edit_box_cd = timer
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    box_sprites.add(b)
                    self.edit_sprite_assignment_list.append(b)
                    print(box_sprites)

            if keyState[pygame.K_v]:
                if timer - self.edit_box_loot_cd >= 1000:
                    a = 'B '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' loot '+str(self.edit_level)
                    b = Box(mx, my, 'loot', self.edit_level)
                    print(a)
                    self.edit_box_loot_cd = timer
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    box_sprites.add(b)

            if keyState[pygame.K_e]:
                if timer - self.edit_Poopyhead_cd >= 1000:
                    a = 'P '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' '+str(self.edit_level)
                    b = Poopyhead(mx, my, self.edit_level)
                    b.touching_floor = False
                    self.edit_Poopyhead_cd = timer
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    enemy_sprites.append(b)
                    gravity_sprites.append(b)

            if keyState[pygame.K_l]:
                if timer - self.edit_PoopyBird_cd >= 1000: # L is for poopy bird
                    a = 'L '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' '+str(self.edit_level)
                    b = Poopy_Bird(mx,my, self.edit_level)
                    self.edit_PoopyBird_cd = timer
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    enemy_sprites.append(b)

            if keyState[pygame.K_1]:
                if timer - self.edit_Popout_Sword_cd >= 1000:
                    a = '1 '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' left '+str(self.edit_level)
                    b = Popout_Sword(mx, my, 'left', self.edit_level)
                    self.edit_Popout_Sword_cd = timer
                    self.edit_assignment_list.append(a)
                    enemy_sprites.append(b)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    floors.append(b.b)
                    scroll_sprites.append(b.b)
                    self.edit_assignment_list.append(b.b)
                    self.edit_sprite_assignment_list.append(b.b)

            if keyState[pygame.K_2]:
                if timer - self.edit_Popout_Sword_cd >= 1000:
                    a = '1 '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' right '+str(self.edit_level)
                    b = Popout_Sword(mx, my, 'right', self.edit_level)
                    self.edit_Popout_Sword_cd = timer
                    self.edit_assignment_list.append(a)
                    enemy_sprites.append(b)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    floors.append(b.b)
                    scroll_sprites.append(b.b)
                    self.edit_assignment_list.append(b.b)
                    self.edit_sprite_assignment_list.append(b.b)

                    floors, enemy_sprites, scroll_sprites

            if keyState[pygame.K_3]:
                if timer - self.edit_Popout_Sword_cd >= 1000:
                    a = '1 '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' up '+str(self.edit_level)
                    b = Popout_Sword(mx, my, 'up', self.edit_level)
                    self.edit_Popout_Sword_cd = timer
                    self.edit_assignment_list.append(a)
                    enemy_sprites.append(b)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    floors.append(b.b)
                    scroll_sprites.append(b.b)
                    self.edit_assignment_list.append(b.b)
                    self.edit_sprite_assignment_list.append(b.b)

            if keyState[pygame.K_4]:
                if timer - self.edit_Popout_Sword_cd >= 1000:
                    a = '1 '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' down '+str(self.edit_level)
                    b = Popout_Sword(mx, my, 'down',self.edit_level)
                    self.edit_Popout_Sword_cd = timer
                    self.edit_assignment_list.append(a)
                    enemy_sprites.append(b)
                    scroll_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    floors.append(b.b)
                    scroll_sprites.append(b.b)
                    self.edit_assignment_list.append(b.b)
                    self.edit_sprite_assignment_list.append(b.b)

            if keyState[pygame.K_o]:
                if timer - self.edit_portapotty_cd >= 1000:
                    a = 'O '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' True '+str(self.edit_level) # if aspect[3] == 'True'
                    b = Portapotty(mx, my, True, self.edit_level)
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    portapotty_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)
                    self.edit_portapotty_cd = timer

            if keyState[pygame.K_m]:
                if timer - self.edit_cannon_cd >= 1000:
                    self.edit_cannon_cd = timer
                    a = 'M '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' left '+str(self.edit_level)
                    b = Cannon(mx, my, 'left', self.edit_level)
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    no_move_enemy_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)

            if keyState[pygame.K_n]:
                if timer - self.edit_cannon_cd >= 1000:
                    self.edit_cannon_cd = timer
                    a = 'M '+str(mx-self.fuckingkms.rect.x)+' '+str(my)+' right '+str(self.edit_level)
                    b = Cannon(mx, my, 'right', self.edit_level)
                    self.edit_assignment_list.append(a)
                    scroll_sprites.append(b)
                    no_move_enemy_sprites.append(b)
                    self.edit_sprite_assignment_list.append(b)

            for sprite in self.edit_sprite_assignment_list:
                if sprite.rect.collidepoint(mx,my):
                    if right_click:
                        del self.edit_assignment_list[self.edit_sprite_assignment_list.index(sprite)]
                        self.edit_sprite_assignment_list.remove(sprite)
                        if sprite in box_sprites:
                            box_sprites.remove(sprite)
                        elif sprite in enemy_sprites:
                            enemy_sprites.remove(sprite)
                        elif sprite in floors:
                            floors.remove(sprite)
                            try:
                                for floor in sprite.under_floor_sprites:
                                    floors.remove(floor)
                            except:
                                pass
                        try:
                            floors.remove(sprite)
                            scroll_sprites.remove(sprite)
                        except:
                            pass
                        scroll_sprites.remove(sprite)

            if keyState[pygame.K_c]: # final compile. hit c to start to write to the txt file.
                if timer - self.edit_compile_timer >= 1000:
                    self.edit_compile_timer = timer
                    if self.edit_level == 1:
                        level_1_file = open('level_1.txt', 'a') # for i in level_1_file: if start of line is g, then i = Ground(). The next number in the line is the sprite's x, etc etc...
                        for sprite in self.edit_assignment_list:
                            level_1_file.write(str(sprite)+'\n')
                    elif self.edit_level == 2:
                        level_2_file = open('level_2.txt', 'a')
                        for sprite in self.edit_assignment_list:
                            level_2_file.write(str(sprite)+'\n')

    fartman = Fartman()
    gravity_sprites.append(fartman)

    class Cannon_Shot(pygame.sprite.Sprite):
        def __init__(self, posx, posy, direction, level):
            pygame.sprite.Sprite.__init__(self)
            self.image = pygame.Surface((30, 30))
            self.image.fill(yellow)
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy

            self.level = level
            self.gravity = 0
            self.direction = direction
            self.touching_floor = True

        def update(self):
            if self.direction == 'left':
                self.rect.x -= 5
            elif self.direction == 'right':
                self.rect.x += 5
            if self.rect.x <= fartman.fuckingkms.rect.x:
                try:
                    enemy_sprites.remove(self)
                    scroll_sprites.remove(self)
                except:
                    pass

        def high_iq_movement(self):
            pass

    class Cannon(pygame.sprite.Sprite):
        def __init__(self, posx, posy, direction, level):
            pygame.sprite.Sprite.__init__(self)
            self.image = pygame.Surface((50, 100))
            self.image.fill(red)
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy

            self.direction = direction
            self.timer = pygame.time.get_ticks()
            self.killable = False
            self.touching_floor = True
            self.gravity = 0
            self.posx, self.posy = posx, posy
            self.level = level

        def update(self):
            timer = pygame.time.get_ticks()
            keyState = pygame.key.get_pressed()

            if timer - self.timer >= 3000:
                self.timer = timer
                for i in range(0,1):
                    i = Cannon_Shot(self.rect.x + 10, self.rect.y + 5, self.direction, self.level)
                    no_move_enemy_sprites.append(i)
                    scroll_sprites.append(i)

        def high_iq_movement(self):
            pass

    portapotty_img = pygame.transform.scale(pygame.image.load('default_porta_potty.png'), (150, 200))
    class Portapotty(pygame.sprite.Sprite):
        def __init__(self, posx, posy, type_, level):
            pygame.sprite.Sprite.__init__(self)
            self.image = portapotty_img
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy

            self.posx, self.posy = posx, posy
            self.end = type_
            self.cd = pygame.time.get_ticks()
            self.reset = False

        def update(self):
            timer = pygame.time.get_ticks()
            if timer - self.cd >= 2000:
                self.cd = timer
                if self.end:
                    if fartman.rect.colliderect(self.rect):
                        fartman.enter_portapotty = True # +70
                        portapotty_sprites.remove(self)
            if self.reset:
                self.rect.x, self.rect.y = self.posx, self.posy
                self.reset = False

    class Rotating_Orbs(pygame.sprite.Sprite):
        def __init__(self):
            pygame.sprite.Sprite.__init__(self)
            self.image = pygame.Surface((25, 25))
            self.image.fill(green)
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = fartman.rect.x - 200, fartman.rect.y + 200

            self.center_x = fartman.rect.centerx
            self.center_y = fartman.rect.centery + 200
            self.angle = 50
            self.radius = 200
            self.speed = 0.05

            self.b = pygame.sprite.Sprite()
            self.b.image = pygame.Surface((25, 25))
            self.b.image.fill(green)
            self.b.image.set_colorkey(white)
            self.b.rect = self.b.image.get_rect()
            self.b.rect.x, self.b.rect.y = fartman.rect.x - 200, fartman.rect.y - 200

        def update(self):
            self.center_x = fartman.rect.centerx
            self.center_y = fartman.rect.centery
            self.rect.x = self.radius * math.sin(self.angle) + self.center_x
            self.rect.y = self.radius * math.cos(self.angle) + self.center_y
            self.b.rect.x = self.radius * math.sin(self.angle) + self.center_x
            self.b.rect.y = self.radius * math.cos(self.angle) + self.center_y
            self.angle += self.speed

    class Popout_Sword(pygame.sprite.Sprite): # a sword that pops out of a specific block. this block will be easily identifiable so the player can avoid the trap.
        def __init__(self, posx, posy, side, level): # side = which side of the block it will come out of
            pygame.sprite.Sprite.__init__(self) # make the box it comes out of really elongated for blitting purposes. blit box over sword.

            self.b = pygame.sprite.Sprite()
            self.side = side
            if side == 'left' or side == 'right':
                self.image = pygame.Surface((300, 30))
                self.b.image = pygame.Surface((300,40))
            else:
                self.image = pygame.Surface((30, 300)) # for the level editor make two seperate keys for the sideways and the vertical
                self.b.image = pygame.Surface((40, 300))

            self.image.fill(red)
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            try:
                self.rect.x, self.rect.y = posx, posy
            except:
                pass

            self.killable = False
            self.ogx, self.ogy = posx, posy
            self.is_popout_sword = True
            self.timer2 = pygame.time.get_ticks()
            self.level = level
            self.gravity = 0
            self.popout = True
            self.ogx, self.ogy = posx, posy

            self.b.image.fill(cyan)
            self.b.image.set_colorkey(white)
            self.b.rect = self.b.image.get_rect()
            if self.side == 'right' or self.side == 'left':
                self.b.rect.x, self.b.rect.y = posx, posy - 5
                self.b.ogx, self.b.ogy = posx, posy - 5
            else:
                self.b.rect.x, self.b.rect.y = posx - 5, posy
                self.b.ogx, self.b.ogy = posx - 5, posy
            self.b.legit = True
            self.reset = False
            self.b.is_popout_sword = True
            self.b.level = level

            self.killable = False
            self.timer = pygame.time.get_ticks()
            self.poke = True
            self.retract = False
            self.gravity = 0
            self.touching_floor = True
            self.no_left = False
            self.no_right = False
            self.changed = 0

        def update(self):
            timer = pygame.time.get_ticks()
            self.touching_floor = True

            if self.side == 'left':
                if self.poke:
                    if self.rect.x >= self.b.rect.x - 295:
                        self.rect.x -= 5
                    else:
                        self.poke = False
                else:
                    if self.rect.x <= self.b.rect.x - 5:
                        self.rect.x += 5
                    else:
                        self.poke = True
            elif self.side == 'right':
                if self.poke:
                    if self.rect.right <= self.b.rect.right + 295:
                        self.rect.x += 5
                    else:
                        self.poke = False
                else:
                    if self.rect.right >= self.b.rect.right + 5:
                        self.rect.x -= 5
                    else:
                        self.poke = True
            elif self.side == 'up':
                if self.poke:
                    if self.rect.y >= self.b.rect.y - 295:
                        self.rect.y -= 5
                    else:
                        self.poke = False
                else:
                    if self.rect.y <= self.b.rect.y - 5:
                        self.rect.y += 5
                    else:
                        self.poke = True
            elif self.side == 'down':
                if self.poke:
                    if self.rect.bottom <= self.b.rect.bottom + 295:
                        self.rect.y += 5
                    else:
                        self.poke = False
                else:
                    if self.rect.bottom >= self.b.rect.bottom + 5:
                        self.rect.y -= 5
                    else:
                        self.poke = True

            if self.reset:
                self.b.rect.x, self.b.rect.y = self.b.ogx, self.b.ogy
                self.rect.x, self.rect.y = self.ogx, self.ogy
                self.reset = False

            if fartman.rect.top in range(self.rect.top + 10, self.rect.bottom) or fartman.rect.bottom in range(self.rect.top + 10, self.rect.bottom) or fartman.rect.centery in range(self.rect.top + 10, self.rect.bottom):
                if fartman.rect.left in range(self.rect.left, self.rect.right) or fartman.rect.right in range(self.rect.left, self.rect.right):
                    if fartman.direction == 'left':
                        fartman.no_left = True
                        self.no_left = True
                        fartman.jump_time = 0
                     #   fartman.no_right = False
                    elif fartman.direction == 'right':
                        fartman.no_right = True
                        fartman.jump_time = 0
                        self.no_right = True
                    #    fartman.no_left = False
                else:
                    self.no_right = False
                    self.no_left = False
            else:
                self.no_right = False
                self.no_left = False
            self.touching_floor = True

        def high_iq_movement(self):
            self.touching_floor = True

    class Platform(pygame.sprite.Sprite):
        def __init__(self, posx, posy):
            pygame.sprite.Sprite.__init__(self)
            self.image = pygame.Surface((300, 15))
            self.image.fill(green)
            self.rect = self.image.get_rect()
            self.rect.centerx, self.rect.centery = posx, posy
            self.legit = True

            self.left_counter = 0
            self.right_counter = 0
            self.onTop = False
            self.decay = pygame.time.get_ticks()
            self.no_left = False
            self.no_right = False

            self.invisible_detection = pygame.sprite.Sprite()
            self.invisible_detection.image = pygame.Surface((300, 12))
            self.invisible_detection.image.fill(white)
            self.invisible_detection.image.set_colorkey(white)
            self.invisible_detection.rect = self.invisible_detection.image.get_rect()
            self.invisible_detection.rect.centerx, self.invisible_detection.rect.bottom = posx, self.rect.bottom
            self.no_up = False
            self.posx, self.posy = posx, posy

            self.invisible_detection2 = pygame.sprite.Sprite()
            self.invisible_detection2.image = pygame.Surface((4, 13))
            self.invisible_detection2.image.fill(white)
            self.invisible_detection2.image.set_colorkey(white)
            self.invisible_detection2.rect = self.invisible_detection2.image.get_rect()
            self.invisible_detection2.rect.left, self.invisible_detection2.rect.top = self.rect.left - 1, self.rect.top + 1

            self.invisible_detection3 = pygame.sprite.Sprite()
            self.invisible_detection3.image = pygame.Surface((4, 13))
            self.invisible_detection3.image.fill(white)
            self.invisible_detection3.image.set_colorkey(white)
            self.invisible_detection3.rect = self.invisible_detection3.image.get_rect()
            self.invisible_detection3.rect.right, self.invisible_detection3.rect.top = self.rect.right + 1, self.rect.top + 1

        def update(self):
            timer = pygame.time.get_ticks()
            if timer - self.decay >= 15000:
                fartman.platforms.remove(self)
                scroll_sprites.remove(self)
                floors.remove(self)

            fartman.invisible_detection.rect.centerx, fartman.invisible_detection.top = fartman.rect.centerx, fartman.rect.top - 1
            self.invisible_detection.rect.centerx, self.invisible_detection.rect.bottom = self.posx, self.rect.bottom + 1
            if fartman.rect.top in range(self.rect.bottom - 3, self.rect.bottom + 3):
                if fartman.rect.left in range(self.rect.left, self.rect.right) or fartman.rect.right in range(self.rect.left, self.rect.right):
                    fartman_jumping = False
                    self.no_up = True
                    print('no detection needed')
                else:
                    self.no_up = False
            else:
                self.no_up = False
            if fartman.rect.colliderect(self.invisible_detection2.rect):
                print('collsiion with left side of platform')
                self.no_right = True
                fartman.no_right = True
                self.right_counter = 0
            else:
                self.right_counter = 1
                fartman.no_right = False
            if fartman.rect.colliderect(self.invisible_detection3.rect):
                print('collision with right side of platform')
                fartman.no_left = True
                self.no_left = True
                self.left_counter = 0
            else:
                self.left_counter = 1
                fartman.no_left = False

            if self.no_up:
                print('sc')
                fartman.jumping = False

    class Poop_Throw_Sprite(pygame.sprite.Sprite):
        def __init__(self, direction):
            pygame.sprite.Sprite.__init__(self)

            self.image = pygame.Surface((6, 6))
            self.image.fill(yellow)
            self.rect = self.image.get_rect()
            self.direction = direction
            self.rate = 3
            if direction == 'right':
                self.rect.centerx, self.rect.centery = fartman.rect.right + 3, fartman.rect.bottom - 30
            elif direction == 'left':
                self.rect.centerx, self.rect.centery = fartman.rect.left - 3, fartman.rect.bottom - 30

        def update(self):
            if self.direction == 'right':
                for floor in floors:
                    if self.rect.colliderect(floor):
                        self.rate = 3
                for box in box_sprites:
                    if not self.rect.right in range(box.rect.left, box.rect.right) and not self.rect.top in range(box.rect.top, box.rect.bottom) or not self.rect.bottom in range(box.rect.top, box.rect.bottom):
                        if self.rect.colliderect(box):
                            self.rate = 3
                    else:
                        if not self.rect.right in range(box.rect.left, box.rect.right+5) or not self.rect.left in range(box.rect.left, box.rect.right+5) and not self.rect.bottom in range(box.rect.y - 2, box.rect.y + 2):
                            try:
                                projectile_sprites.remove(self)
                            except:
                                pass
                        else:
                            if self.rect.colliderect(box):
                                self.rate = 3

                self.rect.x += 6
                self.rect.y -= self.rate
                self.rate -= 0.2
            elif self.direction == 'left': # make it so that if it hits the side of a floor/box it explodes
                for floor in floors:
                    if self.rect.colliderect(floor):
                        self.rate = 3
                for box in box_sprites:
                    if self.rect.colliderect(box):
                        self.rate = 3

                self.rect.x -= 6
                self.rect.y -= self.rate
                self.rate -= 0.2

    Poopyhead_running_left_1_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_1.png').convert(), (42, 50))
    Poopyhead_running_left_2_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_2.png').convert(), (42, 50))
    Poopyhead_running_left_3_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_3.png').convert(), (42, 50))
    Poopyhead_running_left_4_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_4.png').convert(), (42, 50))
    Poopyhead_running_left_5_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_5.png').convert(), (42, 50))
    Poopyhead_running_left_6_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_6.png').convert(), (42, 50))
    Poopyhead_running_left_7_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_7.png').convert(), (42, 50))
    Poopyhead_running_left_8_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_8.png').convert(), (42, 50))
    Poopyhead_running_left_9_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_left_9.png').convert(), (42, 50))

    Poopyhead_running_right_1_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_1.png').convert(), (42, 50))
    Poopyhead_running_right_2_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_2.png').convert(), (42, 50))
    Poopyhead_running_right_3_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_3.png').convert(), (42, 50))
    Poopyhead_running_right_4_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_4.png').convert(), (42, 50))
    Poopyhead_running_right_5_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_5.png').convert(), (42, 50))
    Poopyhead_running_right_6_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_6.png').convert(), (42, 50))
    Poopyhead_running_right_7_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_7.png').convert(), (42, 50))
    Poopyhead_running_right_8_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_8.png').convert(), (42, 50))
    Poopyhead_running_right_9_img = pygame.transform.scale(pygame.image.load('defult_Enemy_poop_running_right_9.png').convert(), (42, 50))

    class Poopyhead(pygame.sprite.Sprite):
        def __init__(self, posx, posy, level):
            pygame.sprite.Sprite.__init__(self)

            self.image = Poopyhead_running_left_1_img
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy

            self.gravity = gravity
            self.direction = 'left'
            self.touching_floor = False
            self.alive = True
            self.coords = self.rect.x, self.rect.y
            self.level = level

            self.running_left_counter = 0
            self.running_right_counter = 0
            self.reset = False
            self.posx, self.posy = posx, posy
            self.killable = True
            self.ogx, self.ogy = posx, posy

        def high_iq_movement(self):
            if self.reset:
                self.rect.x, self.rect.y = self.posx, self.posy
                self.alive = True
                self.reset = False
            if self.direction == 'right':
                self.rect.x += 3
                self.coords = self.rect.x, self.rect.y
                self.running_right_counter += 1
                if self.running_right_counter <= 10:
                    self.image = Poopyhead_running_right_1_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 20:
                    self.image = Poopyhead_running_right_2_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 30:
                    self.image = Poopyhead_running_right_3_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 40:
                    self.image = Poopyhead_running_right_4_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 50:
                    self.image = Poopyhead_running_right_5_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 60:
                    self.image = Poopyhead_running_right_6_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 70:
                    self.image = Poopyhead_running_right_7_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 80:
                    self.image = Poopyhead_running_right_8_img
                    self.image.set_colorkey(white)
                elif self.running_right_counter <= 90:
                    self.image = Poopyhead_running_right_9_img
                    self.image.set_colorkey(white)
                else:
                    self.running_right_counter = 0

            elif self.direction == 'left':
                self.rect.x -= 3
                self.coords = self.rect.x, self.rect.y
                self.running_left_counter += 1
                if self.running_left_counter <= 10:
                    self.image = Poopyhead_running_left_1_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 20:
                    self.image = Poopyhead_running_left_2_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 30:
                    self.image = Poopyhead_running_left_3_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 40:
                    self.image = Poopyhead_running_left_4_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 50:
                    self.image = Poopyhead_running_left_5_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 60:
                    self.image = Poopyhead_running_left_6_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 70:
                    self.image = Poopyhead_running_left_7_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 80:
                    self.image = Poopyhead_running_left_8_img
                    self.image.set_colorkey(white)
                elif self.running_left_counter <= 90:
                    self.image = Poopyhead_running_left_9_img
                    self.image.set_colorkey(white)
                else:
                    self.running_left_counter = 0
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = self.coords

            for enemy in enemy_sprites:
                if enemy != self:
                    if self.direction == 'right':
                        if self.rect.right in range(enemy.rect.right - 3, enemy.rect.right + 3) or self.rect.left in range(enemy.rect.left - 3, enemy.rect.left + 3):
                            self.direction = 'left'
                    elif self.direction == 'left':
                        if self.rect.left in range(enemy.rect.left - 3, enemy.rect.left + 3) or self.rect.right in range(enemy.rect.right - 3, enemy.rect.right + 3):
                            self.direction = 'right'

            height = self.rect.bottom - self.rect.y
            width = self.rect.right - self.rect.x
            for floor in floors:
                if self.rect.right in range(floor.rect.left, floor.rect.right) or self.rect.left in range(floor.rect.left, floor.rect.right):
                    if self.rect.bottom in range(floor.rect.y - 2, floor.rect.y + 30):
                        self.touching_floor = True
                        self.jumping = False
                        self.jump_initial_boost = True
                        self.rect.bottom = floor.rect.top
                        self.gravity = 1.8
                    else:
                        self.toucing_floor = False
                else:
                    self.touching_floor = False

            for box in box_sprites:
                if self.rect.right in range(box.rect.left, box.rect.right) or self.rect.left in range(box.rect.left, box.rect.right):
                    if self.rect.bottom in range(box.rect.y - 3, box.rect.y + 10):
                        self.touching_floor = True
                        self.jumping = False
                        self.rect.bottom = box.rect.top
                        self.gravity = 1.8
                    else:
                        self.touching_floor = False
                else:
                    self.touching_floor = False

            if not self.alive:
                self.kill()

    default_ground_1_img = pygame.image.load('default_Ground_1.png').convert()
    default_ground_under_1_img = pygame.image.load('default_Ground_under_1.png').convert()

    poop_bird_throw_sprites = []
    poopybird_birdpoop_img = pygame.transform.scale(pygame.image.load('Bird_POOP.png').convert(), (14, 18))
    class Poopy_Bird_Poop_Throw(pygame.sprite.Sprite):
        def __init__(self, posx, posy, level):
            pygame.sprite.Sprite.__init__(self)

            self.image = poopybird_birdpoop_img
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy
            self.destination = fartman.rect.x
            self.level = level

            self.direction = None
            self.gravity = 0.8
            self.touching_floor = False
            self.delete = False
            if fartman.rect.x > self.rect.x:
                self.direction = 'right'
            else:
                self.direction = 'left'

        def throw(self):
            for box in box_sprites:
                if self.rect.colliderect(box.rect):
                    self.delete = True
            for floor in floors:
                if self.rect.colliderect(floor.rect):
                    self.delete = True
            if self.rect.y >= 1080:
                self.delete = True
            if self.delete:
                poop_bird_throw_sprites.remove(self)
                gravity_sprites.remove(self)
                enemy_sprites.remove(self)

        def high_iq_movement(self):
            pass

    poopybird_flyingleft_1_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Left_1.png').convert(), (70, 42))
    poopybird_flyingleft_2_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Left_2.png').convert(), (70, 42))
    poopybird_flyingleft_3_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Left_3.png').convert(), (70, 42))

    poopybird_flyingright_1_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Right_1.png').convert(), (70, 42))
    poopybird_flyingright_2_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Right_2.png').convert(), (70, 42))
    poopybird_flyingright_3_img = pygame.transform.scale(pygame.image.load('default_Enemy_poopBird_flying_Right_3.png').convert(), (70, 42))
    class Poopy_Bird(pygame.sprite.Sprite):
        def __init__(self, posx, posy, level):
            pygame.sprite.Sprite.__init__(self)

            self.image = poopybird_flyingleft_1_img
            self.image.set_colorkey(white)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.y = posx, posy
            self.arrived = False
            self.gravity = 0

            self.left_counter = 0
            self.right_counter = 0
            self.level = level
            self.ogx, self.ogy = posx, posy

            self.touching_floor = None
            self.random_locations = range(fartman.rect.x - 700, fartman.rect.x + 700)
            self.random_location = random.choice(self.random_locations)
            self.timer = pygame.time.get_ticks()
            self.throw_cd = pygame.time.get_ticks()
            self.killable = True

        def high_iq_movement(self):
            timer = pygame.time.get_ticks()
            if self.rect.x not in range(self.random_location - 5, self.random_location + 5):
                if self.random_location > self.rect.x:
                    self.rect.x += 8
                    self.left_counter += 1
                    if self.left_counter <= 12:
                        self.image = poopybird_flyingright_1_img
                    elif self.left_counter <= 24:
                        self.image = poopybird_flyingright_2_img
                    elif self.left_counter <= 36:
                        self.image = poopybird_flyingright_3_img
                    elif self.left_counter <= 48:
                        self.image = poopybird_flyingright_2_img
                    elif self.left_counter >= 60:
                        self.left_counter = 0
                    self.image.set_colorkey(white)
                elif self.random_location < self.rect.x:
                    self.rect.x -= 8
                    self.right_counter += 1
                    if self.right_counter <= 12:
                        self.image = poopybird_flyingleft_1_img
                    elif self.right_counter <= 24:
                        self.image = poopybird_flyingleft_2_img
                    elif self.right_counter <= 36:
                        self.image = poopybird_flyingleft_3_img
                    elif self.right_counter <= 48:
                        self.image = poopybird_flyingleft_2_img
                    elif self.right_counter >= 60: # make is so that when it has stopped moving, it plays the facing towards animations
                        self.right_counter = 0
                    self.image.set_colorkey(white)
            else:
                if timer - self.timer >= 4500:
                    self.random_locations = range(fartman.rect.x - 1200, fartman.rect.x + 1200)
                    self.random_location = random.choice(self.random_locations)
                    self.timer = timer

            if timer - self.throw_cd >= 5000 and self.rect.centerx in range(fartman.rect.left - 15, fartman.rect.right + 15):
                for i in range(0,1):
                    i = Poopy_Bird_Poop_Throw(self.rect.x,self.rect.y, self.level) # change here to make the poop actually come out of their hand
                    poop_bird_throw_sprites.append(i)
                    gravity_sprites.append(i)
                    enemy_sprites.append(i)
                    scroll_sprites.append(i)
                self.throw_cd = timer

    class Ground(pygame.sprite.Sprite): # MAKE LEVELS A SEPERATE SCRIPT SO IT DOESN'T ALL LOOK LIKE SHIT
        def __init__(self, posx, posy, level, array): # LITERALLY JUST PUT THE CLASS IN THE OTEHR SCRIPT WHO THE FUCK CARES IF IT LOOKS LIKE SHIT
            pygame.sprite.Sprite.__init__(self)

            # change later
            self.image = default_ground_1_img
            self.rect = self.image.get_rect()
            self.level = level
            self.rect.x, self.rect.y = posx, posy
            self.legit = True
            self.reset = False

            self.posx, self.posy = posx, posy
            self.under_floor_sprites = []
            self.no_left = False
            self.no_right = False
            self.is_popout_sword = False
            self.no_left = False
            self.no_right = False

            self.ihd1 = pygame.sprite.Sprite()
            self.ihd1.image = pygame.Surface((10,self.rect.height - 10))
            self.ihd1.image.fill(red)
            self.ihd1.image.set_colorkey(white)
            self.ihd1.rect = self.ihd1.image.get_rect()
            self.ihd1.rect.x, self.ihd1.rect.y = posx, self.rect.y
            self.ihd1.legit = False

            self.ihd2 = pygame.sprite.Sprite()
            self.ihd2.image = pygame.Surface((10,self.rect.height - 10))
            self.ihd2.image.fill(white)
            self.ihd2.image.set_colorkey(white)
            self.ihd2.rect = self.ihd1.image.get_rect()
            self.ihd2.rect.x, self.ihd2.rect.y = self.rect.right + 5, self.rect.y # after this, do portals

            for i in range(0,1):
                i = pygame.sprite.Sprite()
                i.image = default_ground_under_1_img
                i.rect=i.image.get_rect()
                i.rect.x,i.rect.y=self.rect.x,self.rect.bottom
                i.legit = False
                i.level = self.level
                array.append(i)
                self.under_floor_sprites.append(i)

        def update(self):
            area_y = range(self.rect.top, self.rect.bottom)
            if fartman.rect.colliderect(self.ihd1):
                print('collision with left side')
            if self.reset:
                self.rect.x, self.rect.y = self.posx, self.posy
                self.reset = False
            for y in area_y:
                if y in range(fartman.rect.top, fartman.rect.bottom - 5):
                    if fartman.rect.right in range(self.rect.left - 2, self.rect.right + 2) or fartman.rect.left in range(self.rect.left - 2, self.rect.right + 2):
                        pass
            if fartman.rect.top in range(self.rect.top + 5, self.rect.bottom) or fartman.rect.bottom in range(self.rect.top + 5, self.rect.bottom) or fartman.rect.centery in range(self.rect.top + 5, self.rect.bottom) or fartman.rect.centery + 25 in range(self.rect.top + 5, self.rect.bottom) or fartman.rect.centery - 25 in range(self.rect.top + 5, self.rect.bottom):
                if fartman.rect.left in range(self.rect.left - 5, self.rect.right + 5) or fartman.rect.right in range(self.rect.left - 5, self.rect.right + 5):
                    if fartman.direction == 'left':
                        fartman.no_left = True
                        self.no_left = True
                        fartman.jump_time = 0
                     #   fartman.no_right = False
                    elif fartman.direction == 'right':
                        fartman.no_right = True
                        fartman.jump_time = 0
                        self.no_right = True
                    #    fartman.no_left = False
                else:
                    self.no_right = False
                    self.no_left = False
            else:
                self.no_right = False
                self.no_left = False

    default_block_img = pygame.transform.scale(pygame.image.load('default_Block_1.png').convert(), (55, 55))
    default_itemblock_img = pygame.transform.scale(pygame.image.load('default_ItemBlock_1.png').convert(), (55,55))
    itemblock_hit_img = pygame.transform.scale(pygame.image.load('default_itemBlock_after_being_hit_1.png').convert(), (55, 55))
    class Box(pygame.sprite.Sprite):
        def __init__(self, posx, posy, type_, level):
            pygame.sprite.Sprite.__init__(self)

            if type_ == 'loot':
                self.image = default_itemblock_img
            else:
                self.image = default_block_img

            self.rect = self.image.get_rect()
            self.level = level
            self.type = type_
            self.rect.x, self.rect.y = posx, posy
            self.posx, self.posy = posx, posy
            self.reset = False

            self.ihd1 = pygame.sprite.Sprite()
            self.ihd1.image = pygame.Surface((500,55))
            self.ihd1.image.fill(white)
            self.ihd1.image.set_colorkey(white)
            self.ihd1.rect = self.ihd1.image.get_rect()
            self.ihd1.rect.x, self.ihd1.rect.y = self.rect.x - 5, self.rect.y

            self.ihd2 = pygame.sprite.Sprite()
            self.ihd2.image = pygame.Surface((500,55))
            self.ihd2.image.fill(white)
            self.ihd2.image.set_colorkey(white)
            self.ihd2.rect = self.ihd1.image.get_rect()
            self.ihd2.rect.x, self.ihd2.rect.y = self.rect.right + 5, self.rect.y

            if self.type == 'loot':
                self.is_powerup = ['powerup'] # Odds for whether it releases a coin or a powerup. add more coins to decrease the chance of a powerup
                self.powerup = random.choice(self.is_powerup)
                self.powerups = ['Big', 'poop', 'platform', 'fast', 'rotating orbs']
                self.random_powerup = random.choice(self.powerups)
            self.stop = False
            self.broken = False
            self.broke = False
            self.skia = []
            self.no_left = False
            self.no_right = False

        def update(self):
            if fartman.rect.top in range(self.rect.bottom -5, self.rect.bottom + 5):
                if fartman.rect.left in range(self.rect.left, self.rect.right + 10) or fartman.rect.right in range(self.rect.left - 10, self.rect.right + 10) or fartman.rect.centerx in range(self.rect.left - 10, self.rect.right + 10):
                    if fartman.jump_time >= 250 and fartman.jump_time <= 1000:
                        self.broken = True
                        print('me break')

            x = self.rect.width
            area = range(0,x)
            fartman.invisible_detection.rect.centerx, fartman.invisible_detection.rect.top = fartman.rect.centerx, fartman.rect.top - 1
            self.ihd2.rect.x, self.ihd2.rect.y = self.rect.right + 5, self.rect.y
            self.ihd1.rect.x, self.ihd1.rect.y = self.rect.x - 5, self.rect.y
            if fartman.rect.top in range(self.rect.top + 10, self.rect.bottom) or fartman.rect.bottom in range(self.rect.top + 10, self.rect.bottom) or fartman.rect.top + 30 in range(self.rect.top + 10, self.rect.bottom) or fartman.rect.top + 60 in range(self.rect.top + 10,self.rect.bottom):
                if fartman.rect.left in range(self.rect.left, self.rect.right) or fartman.rect.right in range(self.rect.left, self.rect.right) or fartman.rect.centerx in range(self.rect.left, self.rect.right): # MAKE A COUNTER
                    if fartman.direction == 'left':
                        fartman.no_left = True
                        self.no_left = True
                        fartman.jump_time = 0
                     #   fartman.no_right = False
                    elif fartman.direction == 'right':
                        fartman.no_right = True
                        fartman.jump_time = 0
                        self.no_right = True
                    #    fartman.no_left = False
                else:
                    self.no_right = False
                    self.no_left = False
            else:
                self.no_right = False
                self.no_left = False


            if self.rect.colliderect(fartman.invisible_detection.rect):
                print(fartman.jump_time)
                if fartman.jump_time <= 1000 and fartman.jump_time >= 10:
                    self.broken = True
                    fartman.jumping = False
                    if self.type == 'no loot':
                        box_sprites.remove(self)

            if self.reset:
                self.rect.x, self.rect.y = self.posx, self.posy
                counter = 0
                if self.broken:
                    for i in range(0,1):
                        i = Box(self.posx, self.posy, self.type, self.level)
                        box_sprites.add(self)
                for sprite in box_sprites:
                    if sprite != self:
                        counter += 1
                if counter == len(box_sprites) - 1:
                    if self.broken:
                        for i in range(0,1):
                            i = Box(self.posx, self.posy, self.type, self.level)
                            box_sprites.add(i)
                            scroll_sprites.append(i)

                self.broken = False
                if self.type == 'loot':
                    self.is_powerup = ['powerup'] # Odds for whether it releases a coin or a powerup. add more coins to decrease the chance of a powerup
                    self.powerup = random.choice(self.is_powerup)
                    self.powerups = ['Big', 'poop']
                    self.random_powerup = random.choice(self.powerups)
                self.reset = False

            if self.type == 'loot':
                if not self.stop:
                    if self.powerup == 'powerup':
                        if self.broken: # draw box over powerup
                            self.image = itemblock_hit_img
                            if self.random_powerup == 'Big':
                                print('scra')
                                for i in range(0,1):
                                    i = Powerup_Sprite(self.rect.x, self.rect.y, self.level, 'Big')
                                    i.releasing = True
                                    powerup_sprites.append(i)
                                    gravity_sprites.append(i)
                                    scroll_sprites.append(i)
                                self.stop = True
                            elif self.random_powerup == 'poop':
                                for i in range(0, 1):
                                  i = Powerup_Sprite(self.rect.x, self.rect.y, self.level, 'poop')
                                  i.releasing = True
                                  powerup_sprites.append(i)
                                  gravity_sprites.append(i)
                                  scroll_sprites.append(i)
                                self.stop = True
                            elif self.random_powerup == 'platform':
                                for i in range(0,1):
                                    i = Powerup_Sprite(self.rect.x, self.rect.y, self.level, 'platform')
                                    i.releasing = True
                                    powerup_sprites.append(i)
                                    gravity_sprites.append(i)
                                    scroll_sprites.append(i)
                                self.stop = True
                            elif self.random_powerup == 'fast':
                                for i in range(0,1):
                                    i = Powerup_Sprite(self.rect.x, self.rect.y, self.level, 'fast')
                                    i.releasing = True
                                    powerup_sprites.append(i)
                                    gravity_sprites.append(i)
                                    scroll_sprites.append(i)
                                self.stop = True
                            elif self.random_powerup == 'rotating orbs':
                                for i in range(0,1):
                                    i = Powerup_Sprite(self.rect.x, self.rect.y, self.level, 'rotating orbs')
                                    i.releasing = True
                                    powerup_sprites.append(i)
                                    gravity_sprites.append(i)
                                    scroll_sprites.append(i)
                                self.stop = True
            else:
                if self.broken:
                    self.rect.x = -1000

    class Powerup_Sprite(pygame.sprite.Sprite):
        def __init__(self, posx, posy, level, type_):
            pygame.sprite.Sprite.__init__(self)

            self.image = pygame.Surface((55, 55)) # SIZE OF BOX
            self.image.fill(cyan)
            self.rect = self.image.get_rect()
            self.directions = ['left', 'right']
            self.direction = random.choice(self.directions)

            self.starting_y = posy
            self.level = level
            self.rect.x, self.rect.y = posx, posy
            self.releasing = False
            self.released = False
            self.no_direction_change = True

            self.reset = False
            self.timer = pygame.time.get_ticks()
            self.touching_floor = True
            self.gravity = gravity
            self.type = type_
            self.gravity_counter = 0
            self.timer = pygame.time.get_ticks()

        def update(self):
            timer = pygame.time.get_ticks()
            self.gravity_counter = 0
            if self.reset:
                powerup_sprites.remove(self)
            timer = pygame.time.get_ticks()
            gravity_func(self)
            if self.releasing:
                if self.rect.bottom > self.starting_y:
                    self.rect.y -= 3
                else:
                    if timer - self.timer >= 475:
                        self.released = True
                        self.releasing = False

            if self.released:
                for floor in floors:
                    if self.rect.right in range(floor.rect.left, floor.rect.right) or self.rect.left in range(floor.rect.left, floor.rect.right):
                        if self.rect.bottom in range(floor.rect.y - 2, floor.rect.y + 30):
                            self.touching_floor = True
                            self.rect.bottom = floor.rect.top
                            self.gravity = 1.8
                            self.gravity_counter = 0
                        else:
                            self.toucing_floor = False
                            self.gravity_counter += 1
                    else:
                        self.touching_floor = False
                        self.gravity_counter += 1

                for box in box_sprites:
                    if self.rect.right in range(box.rect.left, box.rect.right) or self.rect.left in range(box.rect.left, box.rect.right):
                        if self.rect.bottom in range(box.rect.y - 3, box.rect.y + 10):
                            self.touching_floor = True
                            self.rect.bottom = box.rect.top
                            self.gravity = 1.8
                            self.gravity_counter = 0
                        else:
                            self.touching_floor = False
                            self.gravity_counter += 1
                    else:
                        self.touching_floor = False
                        self.gravity_counter += 1

                if self.gravity_counter < len(box_sprites) + len(floors):
                    self.touching_floor = True
                else:
                    self.touching_floor = False

                try:
                    if not self.touching_floor:
                        self.gravity *= 1.025
                        self.rect.y += self.gravity
                except:
                    pass

                if self.direction == 'right':
                    self.rect.x += 4
                else:
                    self.rect.x -= 4

    class End_Level_Portapotty(pygame.sprite.Sprite):
        def __init__(self, posx, posy, level, type_):
            pygame.sprite.Sprite.__init__(self)
            self.image = pygame.Surface((200, 400))
            self.image.fill(green)
            self.rect = self.image.get_rect()
            self.rect.x, self.rect.bottom = posx, posy
            self.level_end = False
            self.level = level
            self.type = type_
            # Add self.reset to reset this

        def update(self): # make the portapotty into two sprites.
            pass

    def gravity_func(obj):
        for floor in floors:
            if obj.rect.right in range(floor.rect.left, floor.rect.right) or obj.rect.left in range(floor.rect.left, floor.rect.right):
                if obj.rect.bottom in range(floor.rect.y - 2, floor.rect.y + 30):
                    obj.touching_floor = True
                else:
                    obj.touching_floor = False
            else:
                obj.touching_floor = False

        for box in box_sprites:
            if obj.rect.right in range(box.rect.left, box.rect.right) or obj.rect.left in range(box.rect.left, box.rect.right):
                if obj.rect.bottom in range(box.rect.y - 2, box.rect.y + 30):
                    obj.touching_floor = True
                else:
                    obj.touching_floor = False
            else:
                obj.touching_floor = False

    pygame.font.init()
    def draw():
        font = pygame.font.SysFont('Comic Sans MS', 36)
        textSurface = font.render("Score: " + str(fartman.score), False, (0,0,0))
        textSurface2 = font.render("Lives " + str(fartman.lives), False, (0, 0, 0))
        blit_images = []
        window.blit(textSurface, (10,10))
        window.blit(textSurface2, ((10,50)))

        if fartman.editing_mode:
            textSurface3 = font.render("B for an empty box", False, (0,0,0))
            textSurface4 = font.render("V for a loot box", False, (0,0,0))
            textSurface5 = font.render("E for a Poopyhead", False,(0,0,0))
            textSurface6 = font.render("L for a Poopy Bird", False, (0,0,0))
            textSurface7 = font.render("1 for a Left Popout Sword", False, (0,0,0))
            textSurface8 = font.render("2 for a Right Popout Sword", False, (0,0,0))
            textSurface9 = font.render("3 for a Up Popout Sword", False, (0,0,0))
            textSurface10 = font.render("4 for a Down Popout Sword", False, (0,0,0))
            textSurface11 = font.render('O is for the end Portapotty', False, (0,0,0))
            textSurface12 = font.render('M is for a left-shooting cannon', False, (0,0,0))
            textSurface13 = font.render('N is for a right-shooting cannon', False, (0,0,0))

            window.blit(textSurface3, (300, 100))
            window.blit(textSurface4, (300, 140))
            window.blit(textSurface5, (300, 180))
            window.blit(textSurface6, (300, 220))
            window.blit(textSurface7, (300, 260))
            window.blit(textSurface8, (300, 300))
            window.blit(textSurface9, (300, 340))
            window.blit(textSurface10, (300, 380))
            window.blit(textSurface11, (300, 420))
            window.blit(textSurface12, (300, 460))
            window.blit(textSurface13, (300, 500))

    for floor in floors:
        scroll_sprites.append(floor)
    for box in box_sprites:
        scroll_sprites.append(box)

    left_click = False
    right_click = True
    if level_1_load:
        level_file = open('level_1.txt', 'r')
    elif level_2_load:
        level_file = open('level_2.txt', 'r')

    level_1_regex = re.compile(r'([^,])')
    xd = []

    lines = ''
    for line in level_file.readlines():
        lines += line
        xd.append(line)

    search = level_1_regex.findall(lines)
    sox = level_1_regex.findall(lines)
    sox = ''.join(sox)
    fake_deal = []
    real_deal = []

    def convert_string(string):
        li = string.split(" ")
        return li

    for i in xd:
        for skra in xd:
            a = convert_string(skra)
            fake_deal.append(a)
    real_deal = fake_deal[:int(len(fake_deal)/2)]

    fartmen_presents_img = pygame.image.load('FARTMENPRESENTS.png').convert()
    grayscreen_img = pygame.image.load('grayscreen.png').convert()
    fartmen_presents_fartman_img = pygame.image.load('FARTMENPRESENTFARTMAN.png').convert()
    starting_animation_playing = False

    grayscreen = pygame.sprite.Sprite()
    grayscreen.image = grayscreen_img
    grayscreen.rect = grayscreen.image.get_rect()
    fartmen_presents = pygame.sprite.Sprite()
    fartmen_presents.image = fartmen_presents_img
    fartmen_presents.rect = fartmen_presents.image.get_rect()

    fartman_animation = pygame.sprite.Sprite()
    fartman_animation.image = pygame.transform.scale(fartman_standing_1_img, (3000, 6000))
    fartman_animation.rect = fartman_animation.image.get_rect()
    fartman_animation.rect.right = width / 2
    fartmen_presents_fartman = pygame.sprite.Sprite()
    fartmen_presents_fartman.image = fartmen_presents_fartman_img
    fartmen_presents_fartman.rect = fartmen_presents_fartman.image.get_rect()
    shalack = True
    b=0

    loading_img = pygame.image.load('loading.png').convert()
    loading = pygame.sprite.Sprite()
    loading.image = loading_img
    loading.rect = loading.image.get_rect()
    loading_bar = pygame.sprite.Sprite()
    loading_bar.image = pygame.Surface((1, 92))
    loading_bar.image.fill((201, 201,2))
    loading_bar.rect = loading_bar.image.get_rect()
    loadingtf = False

    loopable_bg_1 = pygame.image.load('Fartman_Background_1.png').convert()
    loopable_bg = pygame.sprite.Sprite()
    loopable_bg.image = loopable_bg_1
    loopable_bg.rect = loopable_bg.image.get_rect()
    loopable_bg_counter = 0
    loopable_bgs = []

    while running:
        clock.tick(60)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                pygame.display.quit()
                sys.exit()
                running = False
            if event.type == pygame.MOUSEBUTTONDOWN:
                if event.button == 1:
                    left_click = True
                    right_click = False
                elif event.button == 3:
                    right_click = True
                    left_click = False
            else:
                left_click = False
                right_click = False

        if fartman.load: #SHOW LOADING SCREEN HERE
            salami = True
            if fartman.level_2_load:
                print('loading level 2')
                level_file = open('level_2.txt', 'r')
                loopable_bg = loopable_bg_2
            elif fartman.level_1_load:
                print('loading level 1')
                level_file = open('level_1.txt', 'r')
                loopable_bg = loopable_bg_1
            else:
                print('Incorrect loading of the level')

            window.blit(loading.image, loading.rect)
            lines = ''
            newlines=0
            newlines_counter=0
            for line in level_file.readlines():
                lines += line
                xd.append(line)
                fake_deal = []
                real_deal = []
                newlines += 1
                for i in xd:
                    for skra in xd:
                        a = convert_string(skra)
                        fake_deal.append(a)
            real_deal = fake_deal[:int(len(fake_deal)/2)]

            counter = 0
            for loop in range(0,10):
                loop = pygame.sprite.Sprite()
                loop.image = loopable_bg
                loop.rect = loop.image.get_rect()
                loop.rect.x = 1920 * counter
                counter += 1
                loopable_bgs.append(loop)

            loot_counter = 0
            if newlines <= 0:
                newlines = 1
            amount_to_increase_bar = 1219/newlines
            loadingtf = True
            if salami and int(newlines) > int(newlines_counter):
                for aspect in real_deal:
                    if newlines_counter >= newlines:
                        break

                    loot_counter = 0
                    time.sleep(0.01)
                    newlines_counter += 1
                    loading_bar.image = pygame.Surface((1 + amount_to_increase_bar * newlines_counter, 92))
                    loading_bar.image.fill((201,201,2))
                    loading_bar.rect.x, loading_bar.rect.y = 351, 529
                    window.blit(loading.image, loading.rect)
                    window.blit(loading_bar.image, loading_bar.rect)
                    pygame.display.flip()
                    pygame.event.get()

                    for i in aspect:
                        if newlines_counter >= newlines:
                            break
                        if loot_counter != 1:
                            type_ = aspect[0]
                            if type_ == 'B':
                                x = aspect[1]
                                y = aspect[2]
                                type2_ = aspect[3]
                                level = aspect[4]
                                i = Box(int(x), int(y), type2_, level)
                                box_sprites.add(i)
                                scroll_sprites.append(i)
                                loot_counter += 1
                            elif type_ == 'G':
                                x = aspect[1]
                                y = aspect[2]
                                level = aspect[3]
                                array = aspect[4]
                                i = Ground(int(x), int(y), level, floors)
                                i.legit = True
                                floors.append(i)
                                scroll_sprites.append(i)
                                loot_counter += 1
                            elif type_ == 'P':
                                x = aspect[1]
                                y = aspect[2]
                                level = aspect[3]
                                i = Poopyhead(int(x), int(y), level)
                                i.touching_floor = False
                                scroll_sprites.append(i)
                                enemy_sprites.append(i)
                                loot_counter += 1
                                gravity_sprites.append(enemy_sprites)
                            elif type_ == 'L':
                                x = aspect[1]
                                y = aspect[2]
                                level = aspect[3]
                                i = Poopy_Bird(int(x), int(y), level)
                                scroll_sprites.append(i)
                                enemy_sprites.append(i)
                                loot_counter += 1
                            elif type_ == '1':
                                x = aspect[1]
                                y = aspect[2]
                                level = aspect[4]
                                direction = aspect[3]
                                i = Popout_Sword(int(x), int(y), direction, level)
                                enemy_sprites.append(i)
                                scroll_sprites.append(i)
                                scroll_sprites.append(i.b)
                                floors.append(i.b)
                                loot_counter += 1
                            elif type_ == 'O':
                                x=aspect[1]
                                y=aspect[2]
                                if aspect[3] == 'True':
                                    tf = True
                                level = aspect[4]
                                i = Portapotty(int(x), int(y), tf, level)
                                scroll_sprites.append(i)
                                portapotty_sprites.append(i)
                                loot_counter += 1
                            elif type_ == 'M':
                                x=aspect[1]
                                y=aspect[2]
                                direction=aspect[3]
                                level = aspect[4]
                                i = Cannon(int(x), int(y), direction, level)
                                scroll_sprites.append(i)
                                no_move_enemy_sprites.append(i)
                                loot_counter += 1

                salami = False

            if fartman.level_2_load:
                fartman.level_2_load = False
            if fartman.level_1_load:
                fartman.level_1_load = False
            fartman.load = False
            fartman.edit_load = False

        a=0
        b=0
        for sprite in fartman.platforms:
            a+=sprite.left_counter
            b+=sprite.right_counter
        if a >= len(fartman.platforms):
            fartman.no_left = False
        else:
            fartman.no_left = True
        if b >= len(fartman.platforms):
            fartman.no_right = False
        else:
            fartman.no_right = True
        if fartman.editing_mode:
            fartman.Editing_Mode()
        try:
            if not starting_animation_playing and not main_menu.showing and not fartman.load:
                for sprite in enemy_sprites:
                    if not sprite.touching_floor:
                        sprite.gravity *= 1.025
                        sprite.rect.y += sprite.gravity
                    elif sprite.touching_floor == None:
                        pass
                    else:
                        sprite.gravity = 1.8

                    for box in box_sprites:
                        if sprite.rect.right in range(box.rect.left-5, box.rect.right+5) or sprite.rect.left in range(box.rect.left-5, box.rect.right+5):
                            if sprite.rect.bottom in range(box.rect.y - 5, box.rect.y + 10):
                                sprite.touching_floor = True
                            else:
                                sprite.touching_floor = False
                        else:
                            sprite.touching_floor = False
        except:
            pass
        try:
            if not main_menu.showing and not starting_animation_playing and not fartman.load:
                for sprite in gravity_sprites:
                    if not sprite.touching_floor:
                        sprite.gravity = sprite.gravity * 1.025
                        sprite.rect.y += sprite.gravity
                    else:
                        sprite.gravity = 1.8
        except:
            pass

        for sprite in enemy_sprites:
            if not main_menu.showing and not starting_animation_playing and not fartman.load:
                if fartman.rect.right in range(sprite.rect.x - 1000, sprite.rect.x + 1000):
                    sprite.high_iq_movement()
                    if sprite.alive == False:
                        enemy_sprites.remove(sprite)
                    sprite.update()
                else:
                    sprite.gravity = 1.8
                    sprite.touching_floor = True

        window.fill(white)

        if main_menu.showing:
            mx, my = pygame.mouse.get_pos()
            if main_menu.new.rect.collidepoint(mx, my):
                main_menu.new.image = main_menu.new.highlighted_img # change here to make new game/continue/quit
                if left_click:
                    starting_animation_playing = True
                    main_menu.showing = False
            else:
                main_menu.new.image = main_menu.new.og_image
            if main_menu.continue_.rect.collidepoint(mx, my):
                main_menu.continue_.image = main_menu.continue_.highlighted_img
                if left_click:
                    fartman.load = True # change here to load files with continue
                    fartman.level_1_load = True
                    starting_animation_playing = False
                    main_menu.showing = False # Change shit here to incorporate save files later.
            else:
                main_menu.continue_.image = main_menu.continue_.og_image
            if main_menu.quit.rect.collidepoint(mx, my):
                main_menu.quit.image = main_menu.quit.highlighted_img
                if left_click:
                    pygame.quit()
                    pygame.display.quit()
                    sys.exit()
                    running = False
            else:
                main_menu.quit.image = main_menu.quit.og_image

            for sprite in mm_sprites:
                window.blit(sprite.image, sprite.rect)

        if not main_menu.showing and not starting_animation_playing and not fartman.load:
            for bg in loopable_bgs:
                window.blit(bg.image, bg.rect)
            for enemy in enemy_sprites:
                window.blit(enemy.image, enemy.rect)
                for box in box_sprites:
                    if enemy.rect.left in range(box.rect.left-5, box.rect.right+5) or enemy.rect.right in range(box.rect.left-5, box.rect.right + 5):
                        if enemy.touching_floor:
                            try:
                                if enemy.direction == 'left':
                                    enemy.direction == 'right'
                                elif enemy.direction == 'right':
                                    enemy.direction == 'left'
                            except:
                                pass
                try:
                    if enemy.popout:
                        enemy.rect.x = enemy.b.rect.x + 5
                except:
                    pass

            for floor in floors:
                try:
                    floor.update()
                    window.blit(floor.image, floor.rect)
                except:
                    print(floor)
                try:
                    if floor.no_up:
                        fartman.jumping = False
                except:
                    pass
            for powerup in powerup_sprites:
                powerup.update()
                window.blit(powerup.image, powerup.rect)
            for box in box_sprites:
                box.update()
                if box.no_left:
                    fartman.no_left = True
                elif box.no_right:
                    fartman.no_right = True
                if not box.broken or box.type == 'loot':
                    window.blit(box.image, box.rect)
            try:
                for sprite in projectile_sprites:
                    sprite.update()
                    window.blit(sprite.image, sprite.rect)
            except:
                pass
            try:
                for sprite in poop_bird_throw_sprites:
                    sprite.throw()
                    window.blit(sprite.image,sprite.rect)
            except:
                pass

            for sprite in all_sprites:
                if sprite.type == 'end_pp':
                    sprite.update()
                    window.blit(sprite.image,sprite.rect)
            for sprite in edit_temp_sprites:
                window.blit(sprite.image, sprite.rect)
            for box in box_sprites:
                box.update()
                if box.no_left:
                    fartman.no_left = True
                elif box.no_right:
                    fartman.no_right = True

            for orb in rotating_orbs_sprites:
                orb.update()
                window.blit(orb.image, orb.rect)
                window.blit(orb.b.image, orb.b.rect)
            for sprite in portapotty_sprites:
                sprite.update()
            try:

                for floor in floors:
                    floor.update()
                    if floor.is_popout_sword:
                        area_y = range(floor.rect.top, floor.rect.bottom)
                        for y in area_y:
                            if y in range(fartman.rect.top, fartman.rect.bottom - 5):
                                if fartman.rect.right in range(floor.rect.left - 5, floor.rect.right + 5) or fartman.rect.left in range(floor.rect.left - 5, floor.rect.right + 5):
                                    if fartman.direction == 'left':
                                        floor.no_left = True
                                        floor.no_right = False
                                    else:
                                        floor.no_left = True
                                    if fartman.direction == 'right':
                                        floor.no_right = True
                                        floor.no_left = False
                                    else:
                                        floor.no_right = False
                                    if floor.no_left:
                                        fartman.no_left = True
                                        floor.no_left = True
                                        fartman.override_no_left = True
                                        fartman.override_no_right = False
                                        fartman.jump_time = 0
                                    elif box.no_right:
                                        fartman.override_no_right = True
                                        fartman.override_no_left = False
                                        fartman.no_right = True
                                        fartman.jump_time = 0
                                        floor.no_right = True
                                else:
                                    floor.no_left = False
                                    floor.no_right = False
                            else:
                                floor.no_left = False
                                floor.no_right = False

                if fartman.touching_floor:
                    fartman.jump_time = 0
            except:
                pass

            for sprite in no_move_enemy_sprites:
                sprite.update()
                window.blit(sprite.image, sprite.rect)

            fartman.touching()
            fartman.movement()
            fartman.stomping_enemies()
            fartman.break_boxes()
            fartman.powerups()
            fartman.end_level()
            window.blit(fartman.image, fartman.rect)
            fartman.invisible_detection.rect.x, fartman.invisible_detection.rect.y = fartman.rect.x, fartman.rect.y - 5
            window.blit(fartman.invisible_detection.image,fartman.invisible_detection.rect)
            draw()

        if starting_animation_playing:
            timer = pygame.time.get_ticks()
            if shalack:
                sa_timer = pygame.time.get_ticks()
                shalack = False

            if timer - sa_timer <= 1500:
                window.blit(grayscreen.image, grayscreen.rect)
            elif timer - sa_timer <= 3000:
                window.blit(fartmen_presents.image, fartmen_presents.rect)
            elif timer - sa_timer <= 4500:
                window.blit(fartmen_presents_fartman.image, fartmen_presents_fartman.rect)
            elif timer - sa_timer <= 24000:
                fartman_animation.rect.top = 0
                fartman_animation.rect.x += 2
                window.blit(fartman_animation.image, fartman_animation.rect)
            elif timer - sa_timer >= 24000 and timer - sa_timer <= 42000:
                fartman_animation.rect.top = -2500
                fartman_animation.rect.x -= 2
                window.blit(fartman_animation.image, fartman_animation.rect)
            elif timer - sa_timer >= 42000 and timer - sa_timer < 60000:
                fartman_animation.rect.x += 2
                fartman_animation.rect.top = -5000
                window.blit(fartman_animation.image, fartman_animation.rect)
            elif timer - sa_timer >= 60000:
                starting_animation_playing = False
                fartman.load = True
                fartman.level_1_load = True

        pygame.display.flip()