Explorateur de cartes

Description

Ce programme est une application graphique permettant de créer, modifier, sauvegarder, et explorer des cartes en utilisant l’algorithme de recherche de chemin A* (A-star). Les cartes sont représentées sous forme de grilles 2D où chaque case peut être soit un espace vide, un obstacle (*), ou un point de départ (X). L’application utilise la bibliothèque tkinter pour l’interface graphique.

Fonctionnalités Principales

Chargement de Carte : Permet de charger une carte depuis un fichier texte.
Sauvegarde de Carte : Permet de sauvegarder la carte actuelle dans un fichier texte.
Création de Carte : Permet de créer une nouvelle carte vierge avec des dimensions spécifiées par l’utilisateur.
Ajout/Modification d’Obstacles et Points de Départ : Permet d’ajouter ou de supprimer des obstacles (*) et de placer des points de départ (X) sur la carte via des clics de souris.
Exploration Automatique : Implémente un algorithme de parcours pour explorer la carte à partir du point de départ (X).
Réaffichage de Carte : Permet de réafficher la carte à partir du fichier texte courant.

Utilisation de l’Interface

Charger Carte : Clique sur ce bouton pour sélectionner un fichier texte et charger une carte dans l’application.
Sauvegarder Carte : Clique sur ce bouton pour enregistrer la carte actuelle dans un fichier texte.
Créer Carte : Clique sur ce bouton pour créer une nouvelle carte avec les dimensions spécifiées dans les champs de saisie de largeur et de hauteur.
Activer/Désactiver Mode X : Clique sur ce bouton pour activer ou désactiver le mode de placement du point de départ (X). Lorsque ce mode est activé, cliquer sur la carte placera un X.
Réafficher Carte : Clique sur ce bouton pour relire et redessiner la carte à partir du fichier texte chargé actuellement.
Explorer Carte : Clique sur ce bouton pour démarrer l’exploration automatique de la carte depuis le point de départ (X).

Fonctions du Programme

1. Fonctions de Gestion de la Carte

lire_carte(fichier) : Lit le contenu d’un fichier texte et le charge dans une liste 2D représentant la carte.
largeur_carte(carte) : Calcule la largeur maximale de la carte.
dessiner_rectangle(col, lig, color) : Dessine un rectangle de couleur spécifiée sur le canevas aux coordonnées données.
dessiner_carte(carte) : Redessine toute la carte sur le canevas en fonction des données de la carte.

2. Fonctions d’Interaction

charger_carte() : Ouvre une boîte de dialogue pour sélectionner un fichier et charger la carte depuis ce fichier.
sauvegarder_carte() : Ouvre une boîte de dialogue pour enregistrer la carte actuelle dans un fichier texte.
creer_carte() : Crée une nouvelle carte vierge avec des dimensions spécifiées par l’utilisateur.
ajouter_obstacle(event) : Ajoute ou supprime un obstacle (*) ou place un point de départ (X) sur la carte en fonction du mode de placement activé, sur la position du clic de souris.
toggle_placer_X_mode() : Active ou désactive le mode de placement de X sur la carte.
reafficher_carte() : Relit et redessine la carte à partir du fichier texte chargé actuellement.

3. Fonctions de Parcours et Algorithme

search_car(carte, car) : Recherche la position d’un caractère donné (par exemple, X) sur la carte.
rechercher_case_adjacente_libre(carte, visites, x, y) : Recherche une case adjacente libre autour d’une position donnée.
rechercher_case_proche_libre(carte, visites, x, y) : Recherche une case libre proche en parcourant une liste de positions visitées.
heuristic(a, b) : Calcule l’heuristique pour l’algorithme A* (distance de Manhattan).
astar_search(map, start, goal) : Implémente l’algorithme A* pour trouver le chemin le plus court entre deux points sur la carte.
explorer_carte() : Démarre le parcours automatique de la carte en utilisant une combinaison de recherche de case libre et l’algorithme A*.

Variables Globales

taille_case : Détermine la taille en pixels de chaque case de la grille.
duree_deplacement : Détermine la durée d’attente entre les mouvements lors de l’exploration automatique.
canvas : Canevas tkinter utilisé pour dessiner la carte.
carte : Liste 2D représentant la carte actuelle.
fichier_courant : Chemin du fichier texte actuellement chargé.
placer_X_mode : Booléen indiquant si le mode de placement du X est activé.

Exigences

Python 3.x
Bibliothèque tkinter (inclus avec Python standard)
Bibliothèque heapq (inclus avec Python standard)
Fichiers de carte au format texte (chaque ligne représente une ligne de la grille, avec * pour obstacles, X pour points de départ, et espace pour les cases libres).

Instructions d’Installation

Assurez-vous que Python 3.x est installé sur votre système.
Enregistrez le script dans un fichier Python (.py).
Exécutez le script depuis un terminal ou un environnement Python compatible.

Exécution

Shell

python editeur_de_carte.py

Exemple de fichier carte

Plain Text

* * * * * * * * *
* X       *     
*   *     *   * 
*   * * * *   * 
*           * *
* * * * * * * *

Les caractères * représentent des obstacles, X représente le point de départ, et les espaces représentent les cases libres.

Programme

Python

import tkinter as tk
from tkinter import filedialog
import time, heapq

taille_case = 20         # Largeur d'un carré en pixels
duree_deplacement = 0.05  # Durée d'un déplacement élémentaire en secondes

def lire_carte(fichier):
    with open(fichier, 'r') as finp:
        r = []
        for ligne in finp:
            r.append(list(ligne.rstrip()))  # Convertir chaque ligne en liste de caractères
        return r

def largeur_carte(carte):
    largeur = 0
    for elt in carte:
        n = len(elt)
        if n > largeur:
            largeur = n
    return largeur

def dessiner_rectangle(col, lig, color):
    x1, y1 = col * taille_case, lig * taille_case
    x2, y2 = x1 + taille_case, y1 + taille_case
    canvas.create_rectangle(x1, y1, x2, y2, fill=color, outline='gray')
    canvas.update()

def search_car(carte, car):
    for i, ligne in enumerate(carte):
        for j, case in enumerate(ligne):
            if case == car:
                return j, i
    return -1, -1

def dessiner_carte(carte):
    canvas.delete("all")  # Effacer la carte actuelle avant de redessiner
    for i, ligne in enumerate(carte):
        for j, case in enumerate(ligne):
            if case == "*":
                color = "black"
            elif case == "X":
                color = "blue"
            else:
                color = "white"
            dessiner_rectangle(j, i, color)

def rechercher_case_adjacente_libre(carte, visites, x, y):
    try:
        if carte[y-1][x] == " " and not (x, y-1) in visites: return x, y-1
        if carte[y][x+1] == " " and not (x+1, y) in visites: return x+1, y
        if carte[y+1][x] == " " and not (x, y+1) in visites: return x, y+1
        if carte[y][x-1] == " " and not (x-1, y) in visites: return x-1, y
    except Exception:
        pass    
    return -1, -1    

def rechercher_case_proche_libre(carte, visites, x, y):
    for (x, y) in reversed(visites):
        x, y = rechercher_case_adjacente_libre(carte, visites, x, y)
        if x != -1:
            return x, y
    return -1, -1    

def heuristic(a, b):
    return abs(a[0] – b[0]) + abs(a[1] – b[1])

def astar_search(map, start, goal):
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]  # Up, Down, Left, Right
    open_list = []
    heapq.heappush(open_list, (0, start))
    g_cost = {start: 0}
    came_from = {start: None}
    while open_list:
        current_priority, current_node = heapq.heappop(open_list)
        if current_node == goal:
            path = []
            while current_node:
                path.append(current_node)
                current_node = came_from[current_node]
            return path[::-1]  # Return reversed path
        for dx, dy in directions:
            neighbor = (current_node[0] + dx, current_node[1] + dy)
            if (0 <= neighbor[0] < len(map) and
                0 <= neighbor[1] < len(map[neighbor[0]])):  # Check variable row lengths
                if map[neighbor[0]][neighbor[1]] == '*':
                    continue  # Skip obstacles
                tentative_g_cost = g_cost[current_node] + 1
                if neighbor not in g_cost or tentative_g_cost < g_cost[neighbor]:
                    g_cost[neighbor] = tentative_g_cost
                    f_cost = tentative_g_cost + heuristic(neighbor, goal)
                    heapq.heappush(open_list, (f_cost, neighbor))
                    came_from[neighbor] = current_node
    return None

def explorer_carte():
    global carte
    xdep, ydep = search_car(carte, "X")
    if xdep == -1 or ydep == -1:
        print("Point de départ 'X' introuvable dans la carte.")
        return

    x, y = xdep, ydep
    visites = [(x, y)]
    b = True
    xx, yy = -1, -1
    while b:
        time.sleep(duree_deplacement)
        xmove, ymove = rechercher_case_adjacente_libre(carte, visites, x, y)
        if xmove == -1:
            xmove, ymove = rechercher_case_proche_libre(carte, visites, x, y)
            if xmove == -1: break
            path = astar_search(carte, (y, x), (ymove, xmove))
            if path == None: break
            for elt in path:
                xx, yy = elt[1], elt[0]
                for i in range(4):
                    dessiner_rectangle(xx, yy, "white")
                    time.sleep(duree_deplacement/4)
                    dessiner_rectangle(xx, yy, "red")
                    time.sleep(duree_deplacement/4)
        visites.append((xmove, ymove))
        dessiner_rectangle(xmove, ymove, "red")
        x, y = xmove, ymove
        time.sleep(duree_deplacement)
    path = astar_search(carte, (y, x), (ydep, xdep))        
    for elt in path:
        xx, yy = elt[1], elt[0]
        for i in range(4):
            dessiner_rectangle(xx, yy, "white")
            time.sleep(duree_deplacement/4)
            dessiner_rectangle(xx, yy, "red")
            time.sleep(duree_deplacement/4)
    dessiner_rectangle(xdep, ydep, "green")            
    print("Parcours fini")

def charger_carte():
    global carte, fichier_courant
    fichier = filedialog.askopenfilename(defaultextension=".txt", filetypes=[("Text Files", "*.txt")])
    if fichier:
        fichier_courant = fichier
        carte = lire_carte(fichier)
        dessiner_carte(carte)

def sauvegarder_carte():
    global carte
    fichier = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text Files", "*.txt")])
    if fichier:
        with open(fichier, 'w') as f:
            for ligne in carte:
                f.write("".join(ligne) + "\n")  # Convertir chaque ligne de liste de caractères en chaîne
        print(f"Carte sauvegardée dans {fichier}")

def creer_carte():
    global carte, canvas
    largeur = int(largeur_entry.get())
    hauteur = int(hauteur_entry.get())
    carte = [[" " for _ in range(largeur)] for _ in range(hauteur)]
    dessiner_carte(carte)

def ajouter_obstacle(event):
    global carte, placer_X_mode
    x, y = event.x // taille_case, event.y // taille_case
    if 0 <= x < len(carte[0]) and 0 <= y < len(carte):
        if placer_X_mode:
            carte[y][x] = "X"  # Place an 'X' on the selected cell
            dessiner_rectangle(x, y, "blue")
        else:
            carte[y][x] = "*" if carte[y][x] == " " else " "
            dessiner_rectangle(x, y, "black" if carte[y][x] == "*" else "white")

def toggle_placer_X_mode():
    global placer_X_mode
    placer_X_mode = not placer_X_mode
    if placer_X_mode:
        bouton_placer_X.config(text="Désactiver Mode X")
    else:
        bouton_placer_X.config(text="Activer Mode X")

def reafficher_carte():
    """Relit et redessine la carte à partir du fichier texte courant."""
    global fichier_courant, carte
    if fichier_courant:
        carte = lire_carte(fichier_courant)
        dessiner_carte(carte)
    else:
        print("Aucun fichier de carte chargé pour réafficher.")

# Initialisation de l'interface graphique
root = tk.Tk()
root.title("Editeur de Carte")

frame_controls = tk.Frame(root)
frame_controls.pack(side=tk.TOP, fill=tk.X)

tk.Button(frame_controls, text="Charger Carte", command=charger_carte).pack(side=tk.LEFT)
tk.Button(frame_controls, text="Sauvegarder Carte", command=sauvegarder_carte).pack(side=tk.LEFT)
tk.Button(frame_controls, text="Explorer Carte", command=explorer_carte).pack(side=tk.LEFT)
tk.Button(frame_controls, text="Réafficher Carte", command=reafficher_carte).pack(side=tk.LEFT)

tk.Label(frame_controls, text="Largeur:").pack(side=tk.LEFT)
largeur_entry = tk.Entry(frame_controls, width=5)
largeur_entry.pack(side=tk.LEFT)
largeur_entry.insert(0, "10")

tk.Label(frame_controls, text="Hauteur:").pack(side=tk.LEFT)
hauteur_entry = tk.Entry(frame_controls, width=5)
hauteur_entry.pack(side=tk.LEFT)
hauteur_entry.insert(0, "10")

tk.Button(frame_controls, text="Créer Carte", command=creer_carte).pack(side=tk.LEFT)

placer_X_mode = False
bouton_placer_X = tk.Button(frame_controls, text="Activer Mode X", command=toggle_placer_X_mode)
bouton_placer_X.pack(side=tk.LEFT)

canvas = tk.Canvas(root, bg="white")
canvas.pack(fill=tk.BOTH, expand=True)
canvas.bind("<Button-1>", ajouter_obstacle)

carte = []
fichier_courant = None  # Initialisation du fichier courant à None
root.mainloop()

Grimeco