Jigsaw Game

import pygame
import random
import datetime
import requests
import time
import json
from random import randint
from tkinter import *
import os
import sqlite3
# from piece import Piece

pygame.init()
pygame.font.init()

global size_info
size_info = pygame.display.Info()

##########################################################################################################

def register():
    global register_screen
    register_screen = Toplevel(main_screen)
    register_screen.title("Register")
    register_screen.geometry("300x250")

    global username
    global password
    global username_entry
    global password_entry
    username = StringVar()
    password = StringVar()

    Label(register_screen, text="Please enter details below", bg="white").pack()
    Label(register_screen, text="").pack()
    username_label = Label(register_screen, text="Username * ")
    username_label.pack()
    username_entry = Entry(register_screen, textvariable=username)
    username_entry.pack()
    password_label = Label(register_screen, text="Password * ")
    password_label.pack()
    password_entry = Entry(register_screen, textvariable=password, show='*')
    password_entry.pack()
    Label(register_screen, text="").pack()
    Button(register_screen, text="Register", width=10, height=1, bg="white", command=register_user).pack()



def login():
    global login_screen
    login_screen = Toplevel(main_screen)
    login_screen.title("Login")
    login_screen.geometry("300x250")
    Label(login_screen, text="Please enter details below to login").pack()
    Label(login_screen, text="").pack()

    global username_verify
    global password_verify

    username_verify = StringVar()
    password_verify = StringVar()

    global username_login_entry
    global password_login_entry

    Label(login_screen, text="Username * ").pack()
    username_login_entry = Entry(login_screen, textvariable=username_verify)
    username_login_entry.pack()
    Label(login_screen, text="").pack()
    Label(login_screen, text="Password * ").pack()
    password_login_entry = Entry(login_screen, textvariable=password_verify, show='*')
    password_login_entry.pack()
    Label(login_screen, text="").pack()
    Button(login_screen, text="Login", width=10, height=1, command=login_verify).pack()


# Implementing event on register button

def register_user():
    username_info = username.get()
    password_info = password.get()
    sql = "INSERT into Users(Username, Password, Stage, StagesCompleted) VALUES (?, ?, ?, ?)"
    with sqlite3.connect("JigsawDB.db") as db:
        cursor = db.cursor()
        try:
            cursor.execute(sql, (username_info, password_info, 1, 0))
            username_entry.delete(0, END)
            password_entry.delete(0, END)

            Label(register_screen, text="Registration Success", fg="green", font=("Ariel Black", 11)).pack()
            register_sucess()
        except sqlite3.IntegrityError:
            print("Username Already In Use")
            username_taken()
# Implementing event on login button


def login_verify():
    global username1
    username1 = username_verify.get()
    password1 = password_verify.get()
    username_login_entry.delete(0, END)
    password_login_entry.delete(0, END)

    with sqlite3.connect("JigsawDB.db") as db:
        cursor = db.cursor()
        cursor.execute("SELECT Username, Password from Users where Username = ?", (username1,))
        data = cursor.fetchall()
    if data:
        if data[0][1] == password1:
            login_sucess()
        else:
            password_not_recognised()
    else:
        user_not_found()


# Designing popup for login success

def login_sucess():
    global login_success_screen
    login_success_screen = Toplevel(login_screen)
    login_success_screen.title("Success")
    login_success_screen.geometry("150x100")
    Label(login_success_screen, text="Login Success").pack()
    Button(login_success_screen, text="OK", command=delete_login_success).pack()


def register_sucess():
    global register_success_screen
    register_success_screen = Toplevel(main_screen)
    register_success_screen.title("Success")
    register_success_screen.geometry("150x100")
    Label(register_success_screen, text="Registration Successful").pack()
    Button(register_success_screen, text="OK", command=delete_register_success).pack()

# Designing popup for login invalid password


def password_not_recognised():
    global password_not_recog_screen
    password_not_recog_screen = Toplevel(main_screen)
    password_not_recog_screen.geometry("150x100")
    Label(password_not_recog_screen, text="Invalid Password ").pack()
    Button(password_not_recog_screen, text="OK", command=delete_password_not_recognised).pack()


# Designing popup for user not found

def user_not_found():
    global user_not_found_screen
    user_not_found_screen = Toplevel(login_screen)
    user_not_found_screen.geometry("150x100")
    Label(user_not_found_screen, text="User Not Found").pack()
    Button(user_not_found_screen, text="OK", command=delete_user_not_found_screen).pack()


def back_to_start():
    main_screen.destroy()
    main_account_screen()


def username_taken():
    global user_taken_screen
    user_taken_screen = Toplevel(register_screen)
    user_taken_screen.geometry("150x100")
    Label(user_taken_screen, text="Username Already In Use").pack()
    Button(user_taken_screen, text="OK", command=back_to_start).pack()

# Deleting popups


def delete_login_success():
    login_success_screen.destroy()
    login_screen.destroy()
    main_screen.destroy()
    main_screen.quit()
    print("Sending to MENU")
    menu()


def delete_register_success():
    register_success_screen.destroy()
    register_screen.destroy()


def delete_password_not_recognised():
    password_not_recog_screen.destroy()


def delete_user_not_found_screen():
    user_not_found_screen.destroy()


# Designing Main(first) window

def main_account_screen():
    global main_screen
    main_screen = Tk()
    main_screen.geometry("300x250")
    main_screen.title("Account Login")
    Label(text="Select Your Choice", bg="light blue", width="300", height="2", font=("Ariel Black", 13)).pack()
    Label(text="").pack()
    Button(text="Login", height="3", width="30", command=login).pack()
    Label(text="").pack()
    Button(text="Register", height="3", width="30", command=register).pack()

    main_screen.mainloop()

####################################################################################################################


class Piece:  # Creates a class which stores each "Piece"
    def __init__(self, frame, x, y, goal_x, goal_y):
        # Each piece stores the frame, goal for x, goal for y, current x, current y and if the piece is selected
        self.frame = frame
        self.goal_x = goal_x
        self.goal_y = goal_y
        self.x = x
        self.y = y
        self.selected = False

    def draw(self, screen, mode):
        # On Each pygame tick it will check if the item is selected or completed, if the user is on
        # EASY mode then it will not show it as green when goal_x = x and goal_y = y (In the correct position)
        screen.blit(self.frame, (self.x, self.y))
        width, height = self.frame.get_size()
        if self.completed():
            if mode == "Easy":  # Checks the MODE/Difficulty
                pygame.draw.rect(screen, (0, 255, 0, 50), (self.x, self.y, width, height), 1)
                # If Easy, Draw a Green Box Around the frame. (0, 255, 0) (RGB)
            else:
                pass  # If It isn't easy mode, continue.
        elif self.selected:  #If the item is selected it will draw a red box around the frame.
            pygame.draw.rect(screen, (255, 0, 0, 50), (self.x, self.y, width, height), 2)
        else:
            # If the piece isn't selected or in the correct location, draw  a black box around it.
            pygame.draw.rect(screen, (0, 0, 0, 50), (self.x, self.y, width, height), 1)

    def swap(self, other):
        # When Two pieces become selected, it swaps there location and stores the new locations.
        self.x, other.x = other.x, self.x
        self.y, other.y = other.y, self.y

    def collision(self, x, y):  # Checks if the location you clicked on has a frame/piece and if so returns it.
        rect = self.frame.get_rect()
        rect = rect.move(self.x, self.y)
        return rect.collidepoint(x, y)

    def completed(self):  # If the piece is in the correct/completed location it shall return True
        return (self.x == self.goal_x) and (self.y == self.goal_y)


def game_over(screen):
    exit_button = pygame.image.load("ExitB.png")
    play_again = pygame.image.load("PlayAgain.png")
    you_win = pygame.image.load("YouWin.png")

    while True:
        for event in pygame.event.get():
            if event.type == pygame.MOUSEBUTTONDOWN:
                mx, my = event.pos
                if mx > size_info.current_w - 115 and my < 32:
                    pygame.quit()
                    quit()
                elif mx < 128 and my < 32:
                    loading = pygame.image.load("loading.jpg")
                    loading2 = pygame.image.load("loading2.jpg")
                    loading3 = pygame.image.load("loading3.jpg")
                    screen.fill((255, 255, 255))
                    loading = pygame.transform.scale(loading, (size_info.current_w, size_info.current_h))
                    screen.blit(loading, (0, 0))
                    pygame.display.update()
                    time.sleep(1)
                    loading2 = pygame.transform.scale(loading2, (size_info.current_w, size_info.current_h))
                    screen.blit(loading2, (0, 0))
                    pygame.display.update()
                    time.sleep(1)
                    loading3 = pygame.transform.scale(loading3, (size_info.current_w, size_info.current_h))
                    screen.blit(loading3, (0, 0))
                    pygame.display.update()
                    time.sleep(1)
                    menu()

            screen.fill((255, 255, 255))
            screen.blit(you_win, (size_info.current_w // 3, size_info.current_w // 3))
            screen.blit(exit_button, (size_info.current_w - 115, 0))
            screen.blit(play_again, (0, 0))

            pygame.display.update()


def get_dog_image():
    found = False
    while not found:
        photo_id = requests.get("https://random.dog/woof").text.lower()
        photo_link = "https://random.dog/" + photo_id

        if photo_id.split(".")[1].lower().endswith("mp4") or photo_id.split(".")[1].lower().endswith("gif"):
            pass
        else:
            photo_id = photo_id.split(".")[0]
            request = requests.get(photo_link)

            if request.status_code == 200:
                with open(photo_id, "wb") as photo:
                    photo.write(request.content)
            return str(photo_id)


def get_cat_image():
    found = False
    while not found:
        photo_id = requests.get("http://aws.random.cat/meow").text.lower()
        photo_link = json.loads(photo_id)["file"]

        if photo_link.endswith('.gif'):
            pass
        else:
            request = requests.get(photo_link)
            name = photo_link.split("dream.io/i/")[1]
            if request.status_code == 200:
                with open(name, "wb") as photo:
                    photo.write(request.content)
                    return str(name)


def strip_from_sheet(sheet, start, size, columns, rows=1):
    frames = []
    for j in range(rows):
        for i in range(columns):
            location = (start[0] + size[0] * i, start[1] + size[1] * j)
            frames.append(sheet.subsurface(pygame.Rect(location, size)))
    return frames


def factors(size, mode):
    if mode == "Easy":
        max_num = 5
    elif mode == "Medium":
        max_num = 15
    elif mode == "Hard":
        max_num = 25
    else:
        max_num = 5
    numbers = [i for i in range(2, max_num)]
    size_factors = []
    for item in numbers:
        if size[0] % item == 0 and size[1] % item == 0:
            size_factors.append(item)
        else:
            pass
    if len(size_factors) > 0:
        return size_factors[-1]
    else:
        return None


def counter(objects):
    count = 0
    for piece_object in objects:
        if piece_object.completed():
            count += 1
        else:
            pass
    return count


def main_game_loop(screen, objects, mode):
    clock = pygame.time.Clock()
    first = datetime.datetime.now()
    first = first.strftime("%M%S")
    game = True
    while game:
        second = datetime.datetime.now()
        second = second.strftime("%M%S")

        total_time = int(second) - int(first)

        screen.fill((255, 255, 255))
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                exit()

            if event.type == pygame.MOUSEBUTTONDOWN:
                mx, my = event.pos
                if mx > 1165 and my > 905:
                    pygame.quit()
                    quit()
                if event.button == 1:
                    select_piece = None
                    for item in objects:
                        if item.selected:
                            select_piece = item

                    for item in objects:
                        if item.collision(mx, my):
                            if select_piece:

                                select_piece.swap(item)
                                select_piece.selected = False
                            else:
                                item.selected = True

                if event.button == 3:
                    for item in objects:
                        item.selected = False

        for item in objects:
            item.draw(screen, mode)

        if counter(objects) == len(objects):
            try:
                with sqlite3.connect("JigsawDB.db") as db:
                    cursor = db.cursor()
                    cursor.execute("UPDATE Users set StagesCompleted=StagesCompleted+1 where Username = ?", (username1,))
            except:
                print("I cri")

            game_over(screen)
            game = False
        else:
            my_font = pygame.font.SysFont('Arial Black', 18)

            hidden = my_font.render("Correct Pieces: HIDDEN", False, (0, 0, 0))
            time_taken = my_font.render('Time: ' + str(total_time), False, (0, 0, 0))
            exit_door = pygame.image.load("exit.png")
            exit_door = pygame.transform.scale(exit_door, (75, 75))
            screen.blit(exit_door, ((size_info.current_w // 30) * 28, size_info.current_h - 100))
            if mode == "Easy" or mode == "Medium":
                scores = my_font.render(f'Correct Pieces: {counter(objects)} / {len(objects)}', False, (0, 0, 0))
                screen.blit(scores, ((size_info.current_w // 10) * 8, 0))
            else:
                screen.blit(hidden, ((size_info.current_w // 10) * 8, 0))

            screen.blit(time_taken, ((size_info.current_w // 10) * 8, 20))

        pygame.display.update()
        clock.tick(60)


def shuffle(split, size, frames, screen, objects, mode):
    random_indices = [i for i in range(split[0] * split[1])]
    random.shuffle(random_indices)
    width = size[0] / split[0]
    height = size[1] / split[1]
    for index, frame in enumerate(frames):
        num = random_indices[index]
        x = width * (num % split[0])
        y = height * (num // split[0])
        goal_x = width * (index % split[0])
        goal_y = height * (index // split[0])
        piece = Piece(frame, x, y, goal_x, goal_y)
        objects.append(piece)

    main_game_loop(screen, objects, mode)


def dog_img():
    found = False
    sheet = ""
    while not found:
        try:
            sheet = pygame.image.load(get_dog_image())
            found = True
        except pygame.error:
            pass
    return sheet


def custom_img():
    import tkinter
    from tkinter import filedialog
    found = False
    while not found:
        try:
            root = tkinter
            root.filename = filedialog.askopenfilename(initialdir="C:\\Users\\186592\\Pictures", title="Select file",
                                                       filetypes=(("png files", "*.png"), ("all files", "*.*")))
            sheet = pygame.image.load(root.filename)
            return sheet
        except pygame.error:
            pass


def cat_img():
    found = False
    sheet = ""
    while not found:
        try:
            sheet = pygame.image.load(get_cat_image())
            found = True
        except pygame.error:
            pass
    return sheet


def adventure_img():
    number = randint(1, 20)
    sheet = pygame.image.load("Image" + str(number) + ".jfif")
    return sheet


def startup(dog=False, adventure=False, custom=False, cat=False, mode=""):
    objects = []

    sheet = ""
    split = ""

    if dog:
        sheet = dog_img()
    elif cat:
        sheet = cat_img()
    elif custom:
        sheet = custom_img()
    elif adventure:
        sheet = adventure_img()

    sheet.set_alpha(255)

    sheet = pygame.transform.scale(sheet, ((size_info.current_w // 10) * 8, size_info.current_h))

    size = sheet.get_size()
    screen = pygame.display.set_mode((size_info.current_w, size_info.current_h), pygame.FULLSCREEN)
    screen.fill((255, 255, 255))
    if factors(size, mode):
        x = factors(size, mode)
        divider = size[0] // x
        split = [size[0] // divider, size[1] // divider]
    frames = strip_from_sheet(sheet, (0, 0), (size[0] / split[0], size[1] / split[1]), split[0], split[1])
    pygame.display.set_caption('Jigsaw Madness')

    shuffle(split, size, frames, screen, objects, mode)


def menu():
    screen = pygame.display.set_mode((size_info.current_w // 3, size_info.current_h // 2))

    easy = False
    medium = False
    hard = False

    mode = ""
    while True:
        for event in pygame.event.get():
            difficulty = pygame.image.load("Difficulty.png")

            easy_photo = pygame.image.load("easy.png")
            selected_easy = pygame.image.load("easyg.png")

            medium_photo = pygame.image.load("medium.png")
            selected_medium = pygame.image.load("mediumg.png")

            hard_photo = pygame.image.load("hard.png")
            selected_hard = pygame.image.load("hardg.png")

            exit_door = pygame.image.load("exit.png")

            dog_text = pygame.image.load("dog.png")
            cat_text = pygame.image.load("cat.png")
            custom_text = pygame.image.load("Custom.png")
            adventure_text = pygame.image.load("adventure.png")

            exit_door = pygame.transform.scale(exit_door, (75, 75))

            my_font = pygame.font.SysFont('Arial Black', 20)
            menu_text = my_font.render('MENU', False, (0, 0, 0))

            screen.fill((255, 255, 255))
            try:
                username_text = my_font.render("Username: " + str(username1), False, (0, 0, 0))
                screen.blit(username_text, (5, 100))
                with sqlite3.connect("JigsawDB.db") as db:
                    cursor = db.cursor()
                    cursor.execute("SELECT StagesCompleted from Users where Username = ?", (username1,))
                    data = cursor.fetchone()
                    if data:
                        Stages_Completed_text = my_font.render("Stages Completed: " + str(data[0]), False, (0, 0, 0))
                        screen.blit(Stages_Completed_text, (5, 125))
            except:
                print("user not logged in")
                pass

            screen.blit(dog_text, (size_info.current_w // 3 - 175, 100))
            screen.blit(cat_text, (size_info.current_w // 3 - 175, 140))
            screen.blit(custom_text, (size_info.current_w // 3 - 175, 180))
            screen.blit(adventure_text, (size_info.current_w // 3 - 175, 220))

            screen.blit(difficulty, (0, size_info.current_h // 2 - size_info.current_h // 5))
            if easy:
                screen.blit(selected_easy, (0, size_info.current_h // 2 - size_info.current_h // 8))
            else:
                screen.blit(easy_photo, (0, size_info.current_h // 2 - size_info.current_h // 8))
            if medium:
                screen.blit(selected_medium, (0, size_info.current_h // 2 - size_info.current_h // 11))
            else:
                screen.blit(medium_photo, (0, size_info.current_h // 2 - size_info.current_h // 11))
            if hard:
                screen.blit(selected_hard, (0, size_info.current_h // 2 - size_info.current_h // 18))
            else:
                screen.blit(hard_photo, (0, size_info.current_h // 2 - size_info.current_h // 18))
            screen.blit(exit_door, (size_info.current_w // 3 - 90, size_info.current_h // 2 - 80))
            screen.blit(menu_text, (size_info.current_w // 7, 30))

            if event.type == pygame.QUIT:
                pygame.quit()
                exit()
            if event.type == pygame.MOUSEBUTTONDOWN:
                mx, my = event.pos
                if 263 > my > 100 and mx > size_info.current_w // 3 - 175:
                    if mode == "":
                        mode = "Easy"
                    if my < 140:
                        startup(dog=True, mode=mode)
                    elif my < 180:
                        startup(cat=True, mode=mode)
                    elif my < 220:
                        startup(custom=True, mode=mode)
                    elif my > 220:
                        startup(adventure=True, mode=mode)
                elif mx < 171 and 385 < my < 498:
                    easy, hard, medium = False, False, False
                    if my < 417:
                        easy = True
                        mode = "Easy"
                    elif my < 457:
                        medium = True
                        mode = "Medium"
                    else:
                        hard = True
                        mode = "Hard"
                elif mx > size_info.current_w // 3 - 90 and my > size_info.current_h // 2 - 80:
                    welcome_screen()
        pygame.display.update()


def welcome_screen():
    screen = pygame.display.set_mode((size_info.current_w // 3, size_info.current_h // 2))
    while True:
        for event in pygame.event.get():
            welcome = pygame.image.load("Welcome.png")
            welcome = pygame.transform.scale(welcome, (size_info.current_w // 3, size_info.current_h // 2))
            screen.fill((255, 255, 255))
            screen.blit(welcome, (0, 0))
            if event.type == pygame.QUIT:
                pygame.quit()
                exit()
            if event.type == pygame.MOUSEBUTTONDOWN:
                mx, my = event.pos
                if 357 > mx > 71:  # Inbounds
                    if my < 234:
                        menu()
                    elif 237 < my < 347:
                        print("LOGIN")
                        main_account_screen()
                    elif 349 < my < 457:
                        print("SETTINGS")
                elif mx > 357 and my > 448:
                    pygame.quit()
                    exit()
        pygame.display.update()


welcome_screen()