pygame.mouse.get_pressed()

click = pygame.mouse.get_pressed()

import pygame
import random
 
 
pygame.init()
 
displey_wight = 800
displey_height = 600
 
displey = pygame.display.set_mode((displey_wight, displey_height))
pygame.display.set_caption('dinorun')
 
 
class objeckt:
 
    global stone, cloud
 
    def __init__(self, x, y, wight, image, speed):
        self.x = x
        self.y = y
        self.wight = wight
        self.image = image
        self.speed = speed
 
    def move(self):
        if self.x >= -self.wight:
            displey.blit(self.image, (self.x, self.y))
            self.x -= self.speed
            return True
        else:
            return False
 
    def return_self(self, radius, y, wight, image):
        self.x = radius
        self.y = y
        self.wight = wight
        self.image = image
        displey.blit(self.image, (self.x, self.y))
 
 
class Button:
    def __init__(self, wight, height,):
        self.wight = wight
        self.height = height
        self.inactive_color = (23, 204, 58)
        self.active_color = (13, 162, 58)
        self.draw_effectes = False
        self.rect_h = 10
        self.rect_w = wight
        self.clear_effects = False
 
    def draw(self, x, y, message, action=None, font_size=30):
        mouse = pygame.mouse.get_pos()
        click = pygame.mouse.get_pressed()
 
        if x < mouse[0] < x + self.wight and y < mouse[1] < y + self.height:
 
            if click[0] == 1:    
                pygame.time.delay(300) 
                if action is not None:
                    if action == quit:
                        pygame.quit()
                        quit()
                    else:
                        action()
 
        self.draw_rect(mouse[0], mouse[1], x, y)
        print_text(message=message, x=x+10, y=y+10, font_size=font_size)
 
    def draw_rect(self, ms_x, ms_y, x, y):
        if x <= ms_x <= x + self.wight and y <= ms_y <= y + self.height:
            self.draw_effectes = True
 
        if self.draw_effectes:
            if self.rect_h < self.height:
                self.rect_h = self.height
            else:
                if ms_x < x or ms_x > x + self.wight or ms_y < y or ms_y> y + self.height:
                    self.clear_effects = True
                    self.draw_effectes = False
 
        if self.clear_effects:
            if self.rect_h > 10:
                self.rect_h = 10
            else:
                self.clear_effects = False
 
        draw_y = y + self.height - self.rect_h
        pygame.draw.rect(displey, self.active_color, (x, draw_y, self.rect_w, self.rect_h))
 
 
user_wight = 60
user_height = 100
user_x = displey_wight//3
user_y = displey_height-user_height-100
 
cactus_wight = 20
cactus_height = 70
cactus_x = displey_wight-50
cactus_y = displey_height-cactus_height-100
 
clock = pygame.time.Clock()
 
make_jump = False
 
jump_counter = 30
 
 
def show_menu():
    menu_backgr = pygame.image.load('menu.jpg')
    show = True
 
    start_button = Button(266, 70)
    quit_button = Button(114, 70)
 
    while show:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
        displey.blit(menu_backgr, (0, 0))
        start_button.draw(20, 200, 'start Game', start_game, font_size=50)
        quit_button.draw(20, 300, 'quit', quit, font_size=50)
        pygame.display.update()
        clock.tick(60)
 
 
def start_game():
    global scores, make_jump, jump_counter, user_y, time_stead
    while game_cycle():
        scores = 0
        make_jump = False
        jump_counter = 30
        user_y = displey_height - user_height - 100
        time_stead = 80
 
 
def game_cycle():
 
    global make_jump
    game = True
    cactus_arr = []
    create_cactus_arr(cactus_arr)
    land = pygame.image.load('fon.jpg')
 
    stone, cloud = open_random_objects()
 
    button = Button(70, 50)
 
    while game:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_SPACE]:
            make_jump = True
 
        if keys[pygame.K_ESCAPE]:
            pause()
 
        if make_jump:
            jump()
 
        count_scores(cactus_arr)
 
        displey.blit(land, (0, 0))
 
        print_text('skores:' + str(scores), 600, 10)
        print_text('spead:' + str(time_stead), 600, 30)
 
        draw_array(cactus_arr)
 
        move_objects(stone, cloud)
 
        draw_dino()
 
        spead()
 
        pygame.display.update()
        clock.tick(time_stead)
 
        if check_collision(cactus_arr):
            game = False
 
    return game_over()
 
 
def jump():
    global user_y, make_jump, jump_counter
    if jump_counter >= -30:
        "if jump_counter == 30:"
        user_y -= jump_counter / 2.5
        jump_counter -= 1
 
    else:
        jump_counter = 30
        make_jump = False
 
 
def create_cactus_arr(array):
    choice = random.randrange(0, 3)
    img = cactus_img[choice]
    wight = cactus_options[choice * 2]
    height = cactus_options[choice * 2 + 1]
    array.append(objeckt(displey_wight + 20, height, wight, img, 4))
    choice = random.randrange(0, 3)
    img = cactus_img[choice]
    wight = cactus_options[choice * 2]
    height = cactus_options[choice * 2 + 1]
    array.append(objeckt(displey_wight + 20, height, wight, img, 4))
    choice = random.randrange(0, 3)
    img = cactus_img[choice]
    wight = cactus_options[choice * 2]
    height = cactus_options[choice * 2 + 1]
    array.append(objeckt(displey_wight + 20, height, wight, img, 4))
 
 
def find_radius(array):
    maximum = max(array[0].x, array[1].x, array[2].x)
 
    if maximum < displey_wight:
        radius = displey_wight
        if radius - maximum < 50:
            radius += 250
    else:
        radius = maximum
    choice = random.randrange(0, 5)
    if choice == 0:
        radius += random.randrange(15, 20)
    else:
        radius += random.randrange(300, 350)
    return radius
 
 
def draw_array(array):
    for cactus in array:
        check = cactus.move()
        if not check:
            radius = find_radius(array)
 
            choice = random.randrange(0, 3)
            img = cactus_img[choice]
            wight = cactus_options[choice * 2]
            height = cactus_options[choice * 2 + 1]
 
            cactus.return_self(radius, height, wight, img)
 
 
def open_random_objects():
 
    choice = random.randrange(0, 2)
    img_of_stone = stone_img[choice]
 
    choice = random.randrange(0, 2)
    img_of_cloud = cloud_img[choice]
 
    stone = objeckt(displey_wight, displey_height - 80, 10, img_of_stone, 4)
    cloud = objeckt(displey_wight, 80, 70, img_of_cloud, 2)
    return stone, cloud
 
 
def move_objects(stone, cloud):
    check = stone.move()
    if not check:
        choice = random.randrange(0, 2)
        img_of_stone = stone_img[choice]
        stone.return_self(displey_wight, 500 + random.randrange(10, 80), stone.wight, img_of_stone)
 
    check = cloud.move()
    if not check:
        choice = random.randrange(0, 2)
        img_of_cloud = cloud_img[choice]
        cloud.return_self(displey_wight, random.randrange(10, 200), cloud.wight, img_of_cloud)
 
 
def draw_dino():
    global img_counter
    if img_counter == 20:
        img_counter = 0
 
    displey.blit(dino_img[img_counter // 5], (user_x, user_y))
    img_counter += 1
 
 
def print_text(message, x, y, front_color=(0, 0, 0), front_type='Samson.ttf', font_size=30):
    front_type = pygame.font.Font(front_type, font_size)
    text = front_type.render(message, True, front_color)
    displey.blit(text, (x, y))
 
 
def pause():
    paused = True
 
 
    while paused:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
        print_text('paused press enter to continue', 160, 300)
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_RETURN]:
            paused = False
        pygame.display.update()
        clock.tick(15)
 
 
def check_collision(barriers):
    for barrier in barriers:
        if barrier.y == 450:
            if not make_jump:
                if barrier.x <= user_x + user_wight - 18 <= barrier.x + barrier.wight:
                    return True
            elif jump_counter >= 0:
                if user_y + user_height - 5 >= barrier.y:
                    if barrier.x <= user_x + user_wight - 18 <= barrier.x + barrier.wight:
                        return True
            else:
                if user_y + user_height - 30 >= barrier.y:
                    if barrier.x <= user_x <= barrier.x + barrier.wight:
                        return True
        else:
            if not make_jump:
                if barrier.x <= user_x + user_wight - 5 <= barrier.x + barrier.wight:
                    return True
            elif jump_counter == 10:
                if user_y + user_height - 5 >= barrier.y:
                    if barrier.x <= user_x + user_wight - 8 <= barrier.x + barrier.wight:
                        return True
            elif jump_counter == -1:
                if user_y + user_height - 5 >= barrier.y:
                    if barrier.x <= user_x + user_wight - 18 <= barrier.x + barrier.wight:
                        return True
            else:
                if user_y + user_height - 25 >= barrier.y:
                    if barrier.x <= user_x + 5 <= barrier.x + barrier.wight:
                        return True
 
    return False
 
 
def count_scores(barriers):
    global scores, max_above
    above_cactus = 0
 
    if -20 <= jump_counter <= 25:
        for barrier in barriers:
            if user_y + user_height - 5 <= barrier.y:
                if barrier.x <= user_x <= barrier.x + barrier.wight:
                    above_cactus += 1
                elif barrier.x <= user_x + user_wight / 2 <= barrier.x + barrier.wight:
                    above_cactus += 1
        max_above = max(max_above, above_cactus)
    else:
        if jump_counter == -30:
            scores += max_above
            max_above = 0
 
 
def game_over():
    global max_scores, scores
    if scores > max_scores:
        max_scores = scores
 
    stopped = True
    while stopped:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
        print_text('game over. Press Enter to play again, Esc to Exit', 40, 300)
        print_text('max scores:' + str(max_scores), 300, 350)
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_RETURN]:
            return True
 
        if keys[pygame.K_ESCAPE]:
            return False
 
        pygame.display.update()
        clock.tick(15)
 
 
def spead():
    global vremia, time_stead
    if scores == vremia:
        vremia += 5
        time_stead += 2
 
 
show_menu()
 
pygame.quit()
quit()