front.py

# coding: utf-8
"""Module gérant l'interface graphique du jeu à l'aide de Pygame"""

# Empèche l'affichage du message de bienvenue de Pygame
from os import environ, path
import sys

environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
import pygame
from game import Board, Piece, shapes
from main import start_recursive_solver


# ----------------------------------------------------------------------------------------------------------

# taille bloc 60x60


def resource_path(relative_path):
    """Retourne le chemin absolu vers la ressource, fonctionne pour le dev et pour PyInstaller"""
    try:
        # PyInstaller crée un dossier temporaire et stocke le chemin dans _MEIPASS
        base_path = sys._MEIPASS
    except Exception:
        base_path = path.abspath(".")

    return path.join(base_path, relative_path)


def init_pieces():
    """Fonctions permettant d'initialiser les pièces et leurs positions (aux positions basiques dans le menu) et de créer la liste des pièces placées sur le board"""
    pieceInBoard = []
    piecesEtPos = []

    for i in range(len(shapes)):
        piecesEtPos.append((Piece(i), (i % 2 * 120, i // 2 * 120 + 50)))
        pieceInBoard.append((-1, -1))

    return piecesEtPos, pieceInBoard


def bouclePrincipale():
    """Fonction principale gérant l'interface graphique du jeu"""

    # Initialisation de Pygame
    pygame.init()
    pygame.font.init()
    my_font = pygame.font.SysFont("Comic Sans MS", 30)
    my_font_title = pygame.font.SysFont("Comic Sans MS", 45)

    pygame.display.set_caption("IQPuzzlerPro Solver")

    icon = pygame.image.load(resource_path("Images/icon.png"))
    pygame.display.set_icon(icon)

    # Création de la fenêtre
    screen = pygame.display.set_mode((1280, 720))

    # Teste si on est dans le programme principal
    running = True

    # Teste si on est en train de drag une piece
    draggingPiece = False

    # Variables pour le solveur
    solveClicked = False
    solved = False
    # result = None
    solutions_count = 0  # Counter for total solutions found
    current_solution_index = 0
    solver_iterator = None

    # Initialisation du board et des variables de menu et d'offsets d'affichage
    board = Board(11, 5)
    drag_offset = pygame.Vector2(0, 0)
    inMenu = False

    # Récupération de l'image de chargement
    imageLoading = pygame.image.load(
        resource_path("Images/loading.png")
    ).convert_alpha()

    # Bouton "Start solving"
    textSolve = my_font.render("Solve !", False, (0, 0, 0))
    solveButton = pygame.Rect(
        screen.get_width() / 2 - (textSolve.get_width() + 20) / 2 - 10,
        500 - 10,
        textSolve.get_width() + 20,
        textSolve.get_height() + 20,
    )

    # Texte "Solved in : Xmilliseconds" et "Done in : Xmilliseconds" (pour le cas d'echec et board déjà résolue)
    textTimeTaken = my_font.render("Solved in :", False, (0, 0, 0))
    textTimeDone = my_font.render("Done in :", False, (0, 0, 0))
    millisecondes = 0.0

    # Texte "Reset"
    textReset = my_font.render("Reset", False, (0, 0, 0))
    resetButton = pygame.Rect(
        screen.get_width() / 2 - (textReset.get_width() + 20) / 2 - 10,
        600 - 10,
        textReset.get_width() + 20,
        textReset.get_height() + 20,
    )

    # Texte "Board already solved"
    textBoardSolved = my_font.render("Board already solved", False, (0, 0, 0))
    alredySolved = False

    # Text "No solution found"
    textNoSolution = my_font.render("No solution found", False, (0, 0, 0))
    noSolution = False

    # Texte "IQ Puzzler Pro Solver"
    textTitle = my_font_title.render("IQ Puzzler Pro Solver", False, (0, 0, 0))

    # Texte "Press R to rotate, F to flip"
    textInstructions = my_font.render("Press R to rotate, F to flip,", False, (0, 0, 0))

    textInstructions2 = my_font.render(
        "Right arrow to navigate solutions", False, (0, 0, 0)
    )

    # Initialisation des listes pour les cases du board et des pièces, ainsi que l'index de la case de la pièce
    casesBoard = []
    casesPiece = []
    pieceInBoard = []
    indexCasePiece = (-1, -1)

    piecesEtPos = []

    # Initialisation des pièces et de leurs positions
    piecesEtPos, pieceInBoard = init_pieces()

    while running:
        # Fond du screen
        screen.fill("purple")
        pygame.draw.rect(
            screen, "purple4", (0, 0, screen.get_width() / 6, screen.get_height())
        )

        # Affichage du titre et des instructions
        screen.blit(
            textTitle,
            (
                screen.get_width() / 2 - textTitle.get_width() / 2,
                30,
            ),
        )

        screen.blit(
            textInstructions,
            (
                screen.get_width() - textInstructions.get_width() - 30,
                screen.get_height() - textInstructions.get_height() - 60,
            ),
        )

        screen.blit(
            textInstructions2,
            (
                screen.get_width() - textInstructions2.get_width() - 30,
                screen.get_height() - textInstructions2.get_height() - 30,
            ),
        )

        # Affichage du board
        casesBoard = board.print_board(screen)

        # Gestion des evènements du joueur
        for event in pygame.event.get():
            # On ferme proprement le programme si on clique sur la croix
            if event.type == pygame.QUIT:
                running = False

            elif event.type == pygame.MOUSEBUTTONDOWN:
                # Bouton "Solve" cliqué
                if solveButton.collidepoint(event.pos):
                    solveClicked = True
                    # Image de chargement
                    screen.blit(
                        imageLoading,
                        (
                            screen.get_width() / 2 - imageLoading.get_width() / 2,
                            screen.get_height() / 2 - imageLoading.get_height() / 2,
                        ),
                    )
                    pygame.display.flip()

                    # On lance le solveur et on récupère toutes les solutions
                    solutions_count = 0
                    millisecondes = 0.0
                    alredySolved = False
                    noSolution = False

                    solver_iterator = start_recursive_solver(board)
                    try:
                        solution_tuple = next(solver_iterator)
                        sol_board, sol_time = solution_tuple

                        if sol_board == -1:
                            print("Board déjà résolu")
                            alredySolved = True
                            solver_iterator = None
                        elif sol_board is None:
                            print("No solution found")
                            noSolution = True
                            millisecondes = sol_time
                            solver_iterator = None
                        else:
                            solutions_count = 1
                            board = sol_board
                            millisecondes = sol_time
                            solved = True
                            current_solution_index = 0
                            piecesEtPos.clear()
                            pieceInBoard.clear()
                    except StopIteration:
                        noSolution = True

                    solveClicked = False

                # Bouton "Reset" cliqué
                elif resetButton.collidepoint(event.pos):
                    # On réinitialise tout
                    board = Board(11, 5)
                    solved = False
                    alredySolved = False
                    noSolution = False
                    millisecondes = 0.0
                    solutions_count = 0
                    current_solution_index = 0
                    solver_iterator = None
                    # On relance l'initialisation des pièces
                    piecesEtPos, pieceInBoard = init_pieces()

                else:
                    # Si on est pas déjà en train de drag une piece
                    if not draggingPiece:
                        indexDraggedPiece = -1
                        found = False
                        # On cherche quelle case de quelle piece on a cliqué
                        for pieceIndex, piecesPourCases in enumerate(casesPiece):
                            if found:
                                break
                            for i, ligne in enumerate(piecesPourCases):
                                if found:
                                    break
                                for j, case in enumerate(ligne):
                                    if case is not None and case.collidepoint(
                                        event.pos
                                    ):
                                        # On trouve la pièce -> on commence à la drag et on note le carré cliqué
                                        draggingPiece = True
                                        indexDraggedPiece = pieceIndex
                                        indexCasePiece = (i, j)
                                        found = True
                                        break
                        # On calcule le offset entre la position de la souris et le coin haut-gauche de la piece
                        if indexDraggedPiece != -1:
                            drag_offset.x = (
                                event.pos[0] - piecesEtPos[indexDraggedPiece][1][0]
                            )
                            drag_offset.y = (
                                event.pos[1] - piecesEtPos[indexDraggedPiece][1][1]
                            )

            # Si on relache le clic gauche
            elif event.type == pygame.MOUSEBUTTONUP:
                # Si la souris est dans les limites de la grille (board)
                if (
                    event.pos[0] < screen.get_width() / 2 + 330
                    and event.pos[0] > screen.get_width() / 2 - 330
                    and event.pos[1] < screen.get_height() / 2 + 250
                    and event.pos[1] > screen.get_height() / 2 - 250
                ):
                    # On parcourt les cases du board pour voir sur laquelle on a relaché la piece
                    for i in range(len(casesBoard)):
                        for j in range(len(casesBoard[i])):
                            if casesBoard[i][j].collidepoint(event.pos):
                                if indexDraggedPiece != -1:
                                    # On vérifie si on peut poser la pièce à cet endroit
                                    if board.canPlaceShape(
                                        piecesEtPos[indexDraggedPiece][0],
                                        (i - indexCasePiece[0], j - indexCasePiece[1]),
                                    ):
                                        # On pose la pièce
                                        board.placeShape(
                                            piecesEtPos[indexDraggedPiece][0],
                                            (
                                                i - indexCasePiece[0],
                                                j - indexCasePiece[1],
                                            ),
                                        )
                                        # On met à jour la position de la pièce
                                        piecesEtPos[indexDraggedPiece] = (
                                            piecesEtPos[indexDraggedPiece][0],
                                            (
                                                screen.get_width() / 2
                                                - 330
                                                + (j - indexCasePiece[1]) * 60,
                                                screen.get_height() / 2
                                                - 250
                                                + (i - indexCasePiece[0]) * 60,
                                            ),
                                        )
                                        pieceInBoard[indexDraggedPiece] = (
                                            i - indexCasePiece[0],
                                            j - indexCasePiece[1],
                                        )
                indexDraggedPiece = -1
                indexCasePiece = (-1, -1)
                draggingPiece = False

            # Quand la souris bouge
            elif event.type == pygame.MOUSEMOTION:
                # On vérifie si on est dans le menu ou sur le board (pour changer la taille des pièces)
                if event.pos[0] < screen.get_width() / 6:
                    if not inMenu:
                        inMenu = True
                        if draggingPiece:
                            drag_offset.x = drag_offset.x // 2
                            drag_offset.y = drag_offset.y // 2

                else:
                    if inMenu:
                        inMenu = False
                        if draggingPiece:
                            drag_offset.x = drag_offset.x * 2
                            drag_offset.y = drag_offset.y * 2
                # Si on est en train de drag la piece, on la deplace avec la souris
                if draggingPiece:
                    if not pieceInBoard[indexDraggedPiece] == (-1, -1):
                        # Si la pièce est déjà placée, on l'enlève de la board
                        if board.inBoard(piecesEtPos[indexDraggedPiece][0]):
                            board.removeShape(
                                piecesEtPos[indexDraggedPiece][0],
                                (
                                    pieceInBoard[indexDraggedPiece][0],
                                    pieceInBoard[indexDraggedPiece][1],
                                ),
                            )
                    piecesEtPos[indexDraggedPiece] = (
                        piecesEtPos[indexDraggedPiece][0],
                        (event.pos[0] - drag_offset.x, event.pos[1] - drag_offset.y),
                    )
            # Si les touches K ou R sont appuyés, on tourne ou on tourne en miroir (flip) la pièce en train d'être dragée
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_r and draggingPiece:
                    piecesEtPos[indexDraggedPiece][0].rotate()
                    # print("Rotation piece")
                elif event.key == pygame.K_f and draggingPiece:
                    piecesEtPos[indexDraggedPiece][0].flip()
                elif event.key == pygame.K_RIGHT:
                    if solver_iterator:
                        try:
                            sol_board, sol_time = next(solver_iterator)
                            solutions_count += 1
                            board = sol_board
                            millisecondes = sol_time
                            current_solution_index = solutions_count - 1
                        except StopIteration:
                            solver_iterator = None

                    if not solver_iterator and solved and solutions_count > 0:
                        # Cycle through solutions
                        current_solution_index = (
                            current_solution_index + 1
                        ) % solutions_count

        # Affichage du bouton "Solve"
        colorSolveButton = "red" if (solveClicked) else "white"
        pygame.draw.rect(screen, colorSolveButton, solveButton)
        screen.blit(
            textSolve, (screen.get_width() / 2 - textSolve.get_width() / 2 - 10, 500)
        )

        # Si la grille est résolue, on affiche le temps mis
        if solved:
            screen.blit(
                textTimeTaken,
                (
                    screen.get_width() - 30 - textTimeTaken.get_width(),
                    30 + textTimeTaken.get_height(),
                ),
            )
            textMilliseconds = my_font.render(
                f"{millisecondes:.2f}milliseconds", False, (0, 0, 0)
            )
            screen.blit(
                textMilliseconds,
                (
                    screen.get_width() - 30 - textMilliseconds.get_width(),
                    30 + textTimeTaken.get_height() * 2,
                ),
            )
            # Display solution count
            if solutions_count > 0:
                textSolutionCount = my_font.render(
                    f"Solution N°{solutions_count}",
                    False,
                    (0, 0, 0),
                )
                screen.blit(
                    textSolutionCount,
                    (
                        screen.get_width() - 30 - textSolutionCount.get_width(),
                        30 + textTimeTaken.get_height() * 3 + 10,
                    ),
                )

        # Si la grille à déjà été résolue, on l'indique
        if alredySolved:
            screen.blit(
                textBoardSolved,
                (
                    screen.get_width() - 30 - textBoardSolved.get_width(),
                    30 + textTimeTaken.get_height(),
                ),
            )
            screen.blit(
                textTimeDone,
                (
                    screen.get_width() - 30 - textTimeDone.get_width(),
                    30 + textTimeDone.get_height() + textBoardSolved.get_height(),
                ),
            )
            textMilliseconds = my_font.render(
                f"{millisecondes:.2f}milliseconds", False, (0, 0, 0)
            )
            screen.blit(
                textMilliseconds,
                (
                    screen.get_width() - 30 - textMilliseconds.get_width(),
                    30 + textTimeDone.get_height() * 2 + textBoardSolved.get_height(),
                ),
            )

        # Si pas de solution, on l'indique
        if noSolution:
            screen.blit(
                textNoSolution,
                (
                    screen.get_width() - 30 - textNoSolution.get_width(),
                    30 + textTimeTaken.get_height(),
                ),
            )
            screen.blit(
                textTimeDone,
                (
                    screen.get_width() - 30 - textTimeDone.get_width(),
                    30 + textTimeDone.get_height() + textNoSolution.get_height(),
                ),
            )
            textMilliseconds = my_font.render(
                f"{millisecondes:.2f}milliseconds", False, (0, 0, 0)
            )
            screen.blit(
                textMilliseconds,
                (
                    screen.get_width() - 30 - textMilliseconds.get_width(),
                    30 + textTimeDone.get_height() * 2 + textNoSolution.get_height(),
                ),
            )

        # Affichage du bouton "Reset"
        if solved or alredySolved or noSolution:
            pygame.draw.rect(screen, "white", resetButton)
            screen.blit(
                textReset,
                (screen.get_width() / 2 - textReset.get_width() / 2 - 10, 600),
            )

        # Affichage des pièces en fonction de leur emplacement (pour choix de la taille)
        casesPiece = [None] * len(piecesEtPos)

        # Afficher d'abord les pièces sur le board (pour quelles soient en dessous des autres)
        for i in range(len(piecesEtPos)):
            if pieceInBoard[i] != (-1, -1):
                if (
                    (board.inBoard(piecesEtPos[i][0]) and not solved)
                    or (piecesEtPos[i][1][0] > screen.get_width() / 6)
                    or (draggingPiece and not inMenu and i == indexDraggedPiece)
                ):
                    temp = piecesEtPos[i][0].print_piece(
                        screen, piecesEtPos[i][1], scale=1
                    )
                else:
                    temp = piecesEtPos[i][0].print_piece(
                        screen, piecesEtPos[i][1], scale=0.5
                    )

                casesPiece[i] = temp

        # Puis afficher les pièces qui ne sont pas sur le board (pour quelle soient au dessus)
        for i in range(len(piecesEtPos)):
            if pieceInBoard[i] == (-1, -1):
                if (
                    (board.inBoard(piecesEtPos[i][0]) and not solved)
                    or (piecesEtPos[i][1][0] > screen.get_width() / 6)
                    or (draggingPiece and not inMenu and i == indexDraggedPiece)
                ):
                    temp = piecesEtPos[i][0].print_piece(
                        screen, piecesEtPos[i][1], scale=1
                    )
                else:
                    temp = piecesEtPos[i][0].print_piece(
                        screen, piecesEtPos[i][1], scale=0.5
                    )

                casesPiece[i] = temp

        # Mise à jour de l'affichage
        pygame.display.flip()

    pygame.quit()