tilemap-tools 0.1.0__py3-none-any.whl

tilemap_tools/__init__.py

@@ -0,0 +1,2 @@
+"""Outils pour créer et manipuler des tilemaps"""
+__version__ = "0.1.0"

tilemap_tools/cli.py

@@ -0,0 +1,76 @@
+"""Point d'entrée principal pour la CLI tilemap"""
+import argparse
+import sys
+from .create_modele import main as create_main
+from .view import main as view_main
+from os import getcwd, listdir, remove
+from os.path import exists, join, dirname
+
+class Check_colors(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        if len(values) < 2: # pyright: ignore[reportArgumentType]
+            parser.error("Vous devez fournir au moins 2 couleurs différentes.")
+        elif len(values) > 16: # pyright: ignore[reportArgumentType]
+            parser.error("Vous ne pouvez pas dessiner un modèle avec plus de 16 couleurs.")
+        else:
+            tests = []
+            for test in values: # pyright: ignore[reportOptionalIterable]
+                if test not in tests:
+                    tests.append(test)
+                else:
+                    parser.error("Les couleurs doivent êtres toutes différentes.")
+        
+        setattr(namespace, self.dest, values)
+
+class Check_fichier(argparse.Action):
+    def __call__(self, parser: argparse.ArgumentParser, namespace: argparse.Namespace, values: str, option_string: str | None = None) -> None:
+        for name in [".mdl", ".map"]:
+            if exists(join(getcwd(), values + name)):
+                break
+        else:
+            parser.error("Vous devez proposer un fichier valide (soit .mdl, soit .map).")
+        
+        setattr(namespace, self.dest, values)
+
+def main():
+    dossier_commande = getcwd()
+    parser = argparse.ArgumentParser(
+        description='Outils pour créer et manipuler des tilemaps (avec pyxel)',
+        usage='tilemap <command> [options]'
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commandes disponibles')
+    
+    # Commande create
+    create_parser = subparsers.add_parser('create', help='Créer une nouvelle tilemap ou un nouveau modèle de tilemap.')
+    create_subparser = create_parser.add_subparsers(dest='type', help="Le type de fichier que tu veut créer.")
+
+    # Créer un modèle
+    create_mdl_parser = create_subparser.add_parser("modele", help='Pour créer un modèle.')
+    create_mdl_parser.add_argument('taille', type=int, help="La taille d'un côté du modèle.")
+    create_mdl_parser.add_argument('output', required=False, type=str, help='Fichier de sortie', default="mon_modèle")
+    create_mdl_parser.add_argument('-n', '--nb-tuiles', type=int, help="Le nombre de tuiles sur le modèle(influe sur la génération de tilemap)", choices=[3, 4], default= 3)
+    create_mdl_parser.add_argument('-c', "--couleurs", nargs="+", action=Check_colors, help="Les couleurs que tu voudrait utiliser (au moins 2 avec leurs codes hex: comme FFFFFF ou 06dd2e)", metavar="HEX", default=None)
+
+    view_parser = subparsers.add_parser('view', help="Permet de consulter un fichier de modèle ou de tilemap.")
+    view_parser.add_argument('fichier', type=str, action=Check_fichier, help="Le fichier que vous voulez consulter (.mdl ou .map)")
+
+    subparsers.add_parser("clean", help="Permet de vider le fichier temporaire qui à peut être été rempli au cours d'erreurs.")
+    
+    # Parse les arguments
+    args = parser.parse_args()
+    
+    # Exécuter la commande appropriée
+    if args.command == 'create_model':
+        create_main(args.taille, args.nb_tuiles, args.output, args.couleurs, dossier_commande)
+    elif args.command == 'view':
+        view_main(args.fichier, dossier_commande)
+    elif args.command == 'clean':
+        dossier = join(dirname(__file__), "pyxres_bin")
+        for file_name in listdir(dossier):
+            remove(join(dossier, file_name))
+    else:
+        parser.print_help()
+
+if __name__ == '__main__':
+    main()

tilemap_tools/core.py

@@ -0,0 +1,70 @@
+"""Fonctions principales pour manipuler les tilemaps"""
+
+class Tilemap:
+    def __init__(self, width, height, default_tile=0):
+        self.width = width
+        self.height = height
+        self.map = [[default_tile for _ in range(width)] for _ in range(height)]
+    
+    def set_tile(self, x, y, tile_id):
+        """Définit une tile à une position donnée"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            self.map[y][x] = tile_id
+        else:
+            raise ValueError(f"Position ({x}, {y}) hors limites")
+    
+    def get_tile(self, x, y):
+        """Récupère la tile à une position donnée"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            return self.map[y][x]
+        raise ValueError(f"Position ({x}, {y}) hors limites")
+    
+    def save_csv(self, filename):
+        """Sauvegarde la tilemap en CSV"""
+        with open(filename, 'w') as f:
+            for row in self.map:
+                f.write(','.join(map(str, row)) + '\n')
+    
+    def save_json(self, filename):
+        """Sauvegarde la tilemap en JSON"""
+        import json
+        data = {
+            'width': self.width,
+            'height': self.height,
+            'tiles': self.map
+        }
+        with open(filename, 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    @staticmethod
+    def load_csv(filename):
+        """Charge une tilemap depuis un CSV"""
+        with open(filename, 'r') as f:
+            lines = f.readlines()
+        
+        map_data = []
+        for line in lines:
+            row = [int(x.strip()) for x in line.strip().split(',') if x.strip()]
+            if row:
+                map_data.append(row)
+        
+        if not map_data:
+            raise ValueError("Fichier CSV vide")
+        
+        height = len(map_data)
+        width = len(map_data[0])
+        
+        tilemap = Tilemap(width, height)
+        tilemap.map = map_data
+        return tilemap
+    
+    @staticmethod
+    def load_json(filename):
+        """Charge une tilemap depuis un JSON"""
+        import json
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        tilemap = Tilemap(data['width'], data['height'])
+        tilemap.map = data['tiles']
+        return tilemap

tilemap_tools/create_modele.py

@@ -0,0 +1,68 @@
+"""Commande pour créer des modèles de tilemaps"""
+from subprocess import run
+from os.path import dirname, join, exists
+from os import remove
+from time import time, sleep
+from pyxel import load, init, images, quit as px_quit, colors as col, Image
+
+def main(taille:int, nb_tiles:int, file:str, colors: None | list[str], dossier:str): # pyright: ignore[reportRedeclaration]
+    print()
+    print("""Vous devez créer un modèle pour tilemap:
+                - Vous devez créer un carré contenant les 4 coins, les 4 cotés et le milieu du modèle
+                - Ce carré sera découpé en 9 (les 4 coins, les 4 cotés et le millieu) pour constituer la base pour une future tilemap.
+                - Après avoir créé votre modèle complet pensez à l'enregistrer puis fermer la fenètre.
+                - Le programme s'occupera de faire le reste pour vous et de l'enregistrer au nom que vous avez choisit (par défault modèle).""")
+    
+    sleep(1)
+
+    init(0, 0)
+
+    nom_fichier_res = f'{join(dirname(__file__), "pyxres_bin", f"bin_{int(time() * 10)}")}'
+
+    if colors is None:
+        colors: list[str] = []
+        for color in col.to_list():
+            colors.append(hex(color)[2:])
+    else:
+        open(nom_fichier_res + ".pyxpal", "w").write("\n".join(map(str, colors)))
+
+    ok = False
+    while not ok:
+        run(["pyxel", "edit", nom_fichier_res])
+
+        try:
+            load(f'{nom_fichier_res}.pyxres')
+            img = images[0]
+            tilemap: list[list[int]] = []
+            nb_0 = 0
+            for x in range(taille * nb_tiles):
+                ligne:list[int] = []
+                for y in range(taille * nb_tiles):
+                    ligne.append(img.pget(x, y))
+                    nb_0 += 1 if img.pget(x, y) == 0 else 0
+                tilemap.append(ligne)
+            if nb_0 != (taille * nb_tiles) ** 2:
+                ok = True
+            test = Image(taille * nb_tiles, taille * nb_tiles)
+            test.blt(0, 0, img, 0, 0, taille * nb_tiles, taille * nb_tiles)
+            test.save(nom_fichier_res + ".png", 1)
+            with open(nom_fichier_res + ".png", "rb") as u:
+                img_png = u.read()
+            with open(join(dossier, file + ".mdl"), "wb") as f:
+                f.write(img_png + f",\n{taille},{nb_tiles},{"\n".join(map(str, colors))}".encode())
+        except Exception as e:
+            ok = False
+            print()
+            print("Il y à eu un problème avec le fichier, pensez à l'enregistrer avant de le fermer.")
+            print(f"Erreur : {e}")
+            print("Tentative suivante dans 1 seconde.")
+            sleep(1)
+            
+    remove(fr"{nom_fichier_res}.pyxres")
+    remove(fr"{nom_fichier_res}.png")
+    if exists(nom_fichier_res + ".pyxpal"):
+        remove(fr"{nom_fichier_res}.pyxpal")
+
+    px_quit()
+
+    

tilemap_tools/view.py

@@ -0,0 +1,159 @@
+"""
+Commande pour voir le contenu du fichier de modèle ou du fichier de tilemap.
+"""
+import tkinter as tk
+from PIL import Image, ImageTk, ImageDraw
+from os.path import join, exists, dirname, abspath
+from os import remove
+from time import time
+
+class TilemapViewer:
+    def __init__(self, root: tk.Tk, image_path, nb_tiles, nom_fichier):
+        self.nb_tiles = nb_tiles
+
+        bg = "#6835c7"
+
+        # Charger l'image
+        self.original_image = Image.open(image_path)
+        
+        # Créer une copie pour dessiner la grille
+        self.display_image = self.original_image.copy()
+        self.display_image = self.display_image.resize((256, 256), Image.NEAREST) # pyright: ignore[reportAttributeAccessIssue]
+        self.tile_size = 256 // nb_tiles
+        self.draw_grid()
+        
+        # Convertir pour Tkinter
+        self.photo = ImageTk.PhotoImage(self.display_image)
+
+        frame = tk.Frame(root, bg=bg)
+        frame.pack(fill=tk.BOTH, expand= True)
+
+        tk.Label(frame, text= f"Voici le contenu du modèle\n{nom_fichier}.mdl", font=("Arial", 20, "bold"), bg=bg).pack()
+        
+        # Canvas
+        self.canvas = tk.Canvas(
+            frame,
+            width=self.display_image.width,
+            height=self.display_image.height,
+            bg='lightgray'
+        )
+        self.canvas.pack(expand= True)
+        
+        # Afficher l'image
+        self.canvas.create_image(128, 128, anchor=tk.CENTER, image=self.photo)
+        
+        # Info label
+        self.info_label = tk.Label(frame, text="Cliquez sur une tuile\n", font=("Arial", 19), pady= 30, bg=bg)
+        self.info_label.pack()
+        
+        # Événement de clic
+        self.canvas.bind("<Button-1>", self.on_tile_click)
+        self.canvas.bind("<B1-Motion>", self.on_tile_click)
+    
+    def draw_grid(self):
+        """Dessine la grille sur l'image"""
+        draw = ImageDraw.Draw(self.display_image)
+        
+        # Lignes verticales
+        for x in range(0, self.display_image.width, self.tile_size):
+            draw.line(
+                [(x, 0), (x, self.display_image.height)],
+                fill=(255, 0, 0, 128),
+                width=1
+            )
+        
+        # Lignes horizontales
+        for y in range(0, self.display_image.height, self.tile_size):
+            draw.line(
+                [(0, y), (self.display_image.width, y)],
+                fill=(255, 0, 0, 128),
+                width=1
+            )
+    
+    def on_tile_click(self, event):
+        """Gérer le clic sur une tuile"""
+        if event.x >= self.display_image.width or event.x <= 0 or event.y <= 0 or event.y >= self.display_image.height:
+            self.canvas.delete("highlight")
+            self.info_label.config(text="Cliquez sur une tuile\n")
+            return
+        tile_x = event.x // self.tile_size
+        tile_y = event.y // self.tile_size
+
+        if tile_x == 0:
+            x_position = "gauche"
+        elif tile_x == self.nb_tiles - 1:
+            x_position = "droite"
+        else:
+            x_position = None
+
+        if tile_y == 0:
+            y_position = "haut"
+        elif tile_y == self.nb_tiles - 1:
+            y_position = "bas"
+        else:
+            y_position = None
+
+        if (tile_x == 0 or tile_x == self.nb_tiles - 1) and (tile_y == 0 or tile_y == self.nb_tiles - 1):
+            nom = f"coin en {y_position} à {x_position}"
+        elif tile_x == 0 or tile_x == self.nb_tiles - 1 or tile_y == 0 or tile_y == self.nb_tiles - 1:
+            if x_position:
+                nom = f"coté {x_position if x_position == "gauche" else "droit"}"
+            else:
+                nom = f"{y_position}"
+        else:
+            nom = "millieu"
+
+        nom += f"\n({tile_x}, {tile_y})"
+        
+        # Mettre à jour l'info
+        self.info_label.config(
+            text=f"Tuile sélectionnée : {nom}"
+        )
+        
+        # Surligner la tuile
+        self.highlight_tile(tile_x, tile_y)
+    
+    def highlight_tile(self, tile_x, tile_y):
+        """Surligner une tuile"""
+        # Effacer les anciens rectangles
+        self.canvas.delete("highlight")
+        
+        # Dessiner un nouveau rectangle
+        x1 = tile_x * self.tile_size
+        y1 = tile_y * self.tile_size
+        x2 = x1 + self.tile_size
+        y2 = y1 + self.tile_size
+        
+        self.canvas.create_rectangle(
+            x1, y1, x2, y2,
+            outline="yellow",
+            width=3,
+            tags="highlight"
+        )
+
+def main(nom_fichier:str, dossier:str):
+    fichier_temp = join(abspath(dirname(__file__)), "pyxres_bin", f"bin_{int(time() * 10)}")
+
+    for name in [".mdl", ".map"]:
+        if exists(join(dossier, nom_fichier + name)):
+            fichier = join(dossier, nom_fichier + name)
+            extension = name
+            break
+
+    if extension == ".mdl":
+        with open(fichier, "rb") as f:
+            liste = f.read().split(b",")
+            img = liste[0]
+            nb_tuiles = int(liste[2].decode())
+        with open(fichier_temp + ".png", "wb") as f:
+            f.write(img)
+        root = tk.Tk()
+        root.title("Affichage de la tilemap.")
+        root.grid_rowconfigure([0, 1], weight=1)
+        root.geometry("500x500")
+
+        TilemapViewer(root, fichier_temp + ".png", nb_tuiles, nom_fichier)
+        
+        root.mainloop()
+
+        remove(fichier_temp + ".png")

tilemap_tools-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: tilemap-tools
+Version: 0.1.0
+Summary: Outils CLI pour créer et manipuler des tilemaps
+Home-page: https://github.com/Julosse27/tilemap-tools
+Author: Julosse
+Author-email: Julosse <julosse27110@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Tilemap Tools
+
+Outils en ligne de commande pour créer et manipuler des tilemaps en pixel art.
+
+## Installation
+```bash
+pip install tilemap-tools
+```
+
+## Fonctionnalités
+
+ - ✨ Créer des modèles de tilemaps interactifs.
+ - 🎨 Des palettes max de 16 couleurs pour un modèle.
+ - 👁️ Visualisation et modification avec des grilles interactives
+ - 👾 Création de tilemaps (à terminer) avec un systrème complet de création de platformes
+ - 👨‍💻 Utilisation facile dans un programme utilisant pyxel (a faire)
+ - 💻 Modification à tout moment (encore à implémenter)
+
+## Utilisation
+
+### Créer un modèle
+```bash
+tilemap create modele 9 -c FF0000 00FF00 0000FF
+tilemap create modele 12 mon_modèle_perso -n 4
+```
+
+### Visualiser un modèle ou une tilemap
+```bash
+tilemap view mon_modèle
+```
+
+### Vider les fichiers temporaires (peuvent s'accumuler au cours d'erreurs)
+```bash
+tilemap clear
+```
+
+## Examples
+```bash
+# Pour créer un modèle avec 3x3 tuiles de 9 pixels chacuns
+tilemap create modele 9 niveau1
+
+# Créer avec des couleurs personnalisées
+tilemap create modele 9 niveau2 -c FF0000 00FF00 0000FF FFFF00
+
+# Visualiser
+tilemap view niveau1
+```
+
+## Dévellopement
+```bash
+git clone https://github.com/Julosse27/tilemap-tools.git
+cd tilemap-tools
+pip install -e .
+```
+
+## License
+
+MIT License - voir LICENSE pour plus de détails.
+
+## Auteur
+
+Julosse - julosse27110@gmail.com

tilemap_tools-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tilemap_tools/__init__.py,sha256=jlIS0AJLJPe4VCdWJmrEPVk2nUoYOQMRSXUHahGLW04,73
+tilemap_tools/cli.py,sha256=3GVMMhTv3NRVouFkkwMTyYOj_zdY2UwiyzHN5q5e2T8,3795
+tilemap_tools/core.py,sha256=MJKSst3av8NgI7zRTgMFM4RMIQ4fL7w_3Jl_kNHQmQA,2313
+tilemap_tools/create_modele.py,sha256=JwbocxIvpFO8xYag1cnLjwQFGtIbnQCS_oXGnX0GQ9Q,2893
+tilemap_tools/view.py,sha256=EEObK4OY0HNWXr99sw5-iXd290KojKAmoCj6z8zG69k,5509
+tilemap_tools-0.1.0.dist-info/licenses/LICENSE,sha256=alZWv-FR5LCCJcddmFtpVYJuFmV_ysI0F88EyipxB78,1086
+tilemap_tools-0.1.0.dist-info/METADATA,sha256=3i1Y5BTiUlOYck_vqQkztqVXKsYpYa7rit62A563BP8,1900
+tilemap_tools-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+tilemap_tools-0.1.0.dist-info/top_level.txt,sha256=Tke14ObRv7S8RCzOnM-F1wO9mBwb5UkheoKs2lWWE2U,14
+tilemap_tools-0.1.0.dist-info/RECORD,,

tilemap_tools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tilemap_tools-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julosse27
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tilemap_tools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tilemap_tools