chore: Refactor code to improve knight movement and update maze configuration

Effects/animated_gif.py

@@ -1,4 +1,4 @@
-import tkinter as tk
+import pyglet
 import itertools
 
 class AnimatedGif:
@@ -11,12 +11,12 @@ class AnimatedGif:
         i = 0
         while True:
             try:
-                image = tk.PhotoImage(file=path, format='gif -index %i' %(i))
-                resized_image = image.subsample(1)  # Resize image to half
-                self.frames.append(resized_image)
+                image = pyglet.image.load_animation(path)
+                frame = image.get_texture(i)
+                self.frames.append(frame)
                 
                 i += 1
-            except tk.TclError:
+            except IndexError:
                 break
 
     def next_frame(self):

Effects/order_click.py

@@ -8,7 +8,7 @@ class OrderClick:
     def next_frame(self, canvas: Canvas) -> bool:
         self.radius -= 5
         shift = 30
-        canvas.create_oval(self.position[0]-self.radius, self.position[1]-self.radius/2+shift, self.position[0]+self.radius, self.position[1]+self.radius/2+shift, fill="", tags="effect", outline=self.color, width=2)
+        #canvas.create_oval(self.position[0]-self.radius, self.position[1]-self.radius/2+shift, self.position[0]+self.radius, self.position[1]+self.radius/2+shift, fill="", tags="effect", outline=self.color, width=2)
         
         if not self.radius:
             return False

Units/hound.py

@@ -1,62 +0,0 @@
-import tkinter as tk
-import os
-import glob
-import time
-import random
-
-from Effects.animated_gif import AnimatedGif
-from Effects.order_click import OrderClick
-
-class Unit:
-    def __init__(self, engine, position=(0,0)):
-        self.engine = engine
-        self.position = position
-        self.target = position
-        self.destination = position
-        gifs = glob.glob("assets/Hound/**/*.gif", recursive=True)
-        self.animation = {os.path.basename(gif): AnimatedGif(gif) for gif in gifs}
-        self.state = "Walk"
-        self.speed = .025  # This is now the delay between updates in seconds
-        self.partial_move = 0
-        self.direction = 2
-        self.visited = [self.position]
-        self.starting_position = (position)
-        self.already_tried = []
-
-    def  move(self, target):
-        pass
-
-
-    def ai(self):
-        screen_x, screen_y = self.engine.iso_transform(*self.position)
-        if  self.position != self.target:
-            self.direction = self.engine.get_direction(self.position,self.destination)
-            if self.partial_move<1:
-                screen_x_dest, screen_y_dest = self.engine.iso_transform(*self.destination)
-                self.partial_move += self.speed
-                screen_x += (screen_x_dest - screen_x) * self.partial_move
-                screen_y += (screen_y_dest - screen_y) * self.partial_move
-            else:
-                screen_x, screen_y = self.engine.iso_transform(*self.destination)
-                neighbors_list = self.engine.find_neighbors(self.destination) # Get the neighbors of the destination cell
-                # Remove any neighbors that are not walkable
-                neighbors_list = [cell for cell in neighbors_list if self.engine.battlefield[cell[1]][cell[0]].walkable]
-                # Update position and visited list
-                self.position = self.destination
-                self.destination = None
-                self.visited.append(self.position)
-                self.destination = self.engine.get_closest_neighbor(neighbors_list,self.target)
-                self.partial_move = 0
-        else:
-            self.visited = [self.target]
-            self.position = self.target
-            self.starting_position = self.target
-            self.destination = self.target
-            self.state = "Idle"
-            self.partial_move = 1
-        gif = self.animation.get(f'{self.state}_dir{self.direction}.gif')
-        return gif, screen_x, screen_y
-    
-    def move_to(self, target):
-        self.target = target
-        self.state = "Walk"

Units/knight.py

@@ -1,39 +1,41 @@
-import tkinter as tk
+import pyglet
 import os
 import glob
-import time
-import random
 
 from Effects.animated_gif import AnimatedGif
 from Effects.order_click import OrderClick
 
-class Unit:
+class Knight:
     def __init__(self, engine, position=(0,0)):
         self.engine = engine
         self.position = position
-        self.target = position
+        self.target = (8,5)
         self.destination = position
         gifs = glob.glob("KnightBasic/**/*.gif", recursive=True)
-        self.animation = {os.path.basename(gif): AnimatedGif(gif) for gif in gifs}
+        self.animation = {os.path.basename(gif): pyglet.sprite.Sprite(pyglet.resource.animation(gif)) for gif in gifs}
         self.state = "Walk"
-        self.speed = .05  # This is now the delay between updates in seconds
+        self.speed = .025  # This is now the delay between updates in seconds
         self.partial_move = 0
-        self.direction = 2
+        self.direction = 7
         self.visited = [self.position]
         self.starting_position = (position)
-        self.already_tried = []
-
-    def  move(self, target):
-        pass
-
 
     def ai(self):
         screen_x, screen_y = self.engine.iso_transform(*self.position)
-        if  self.position != self.target:
+        if  self.position == self.target:
+            self.visited = [self.target]
+            self.position = self.target
+            self.starting_position = self.target
+            self.destination = self.target
+            self.state = "Idle"
+            self.partial_move = 1
+        else:
             self.direction = self.engine.get_direction(self.position,self.destination)
             if self.partial_move<1:
                 screen_x_dest, screen_y_dest = self.engine.iso_transform(*self.destination)
                 self.partial_move += self.speed
+                if self.partial_move > 1:
+                    self.partial_move = 1
                 screen_x += (screen_x_dest - screen_x) * self.partial_move
                 screen_y += (screen_y_dest - screen_y) * self.partial_move
             else:
@@ -41,22 +43,23 @@ class Unit:
                 neighbors_list = self.engine.find_neighbors(self.destination) # Get the neighbors of the destination cell
                 # Remove any neighbors that are not walkable
                 neighbors_list = [cell for cell in neighbors_list if self.engine.battlefield[cell[1]][cell[0]].walkable]
-                # Update position and visited list
                 self.position = self.destination
-                self.destination = None
-                self.visited.append(self.position)
                 self.destination = self.engine.get_closest_neighbor(neighbors_list,self.target)
                 self.partial_move = 0
-        else:
-            self.visited = [self.target]
-            self.position = self.target
-            self.starting_position = self.target
-            self.destination = self.target
-            self.state = "Idle"
-            self.partial_move = 1
+
         gif = self.animation.get(f'Knight_{self.state}_dir{self.direction}.gif')
         return gif, screen_x, screen_y
 
     def move_to(self, target):
+        if self.target == target and self.state == "Walk":
+            return
+        self.speed = .05
         self.target = target
         self.state = "Walk"
+    
+    def run_to(self, target):
+        if self.target == target and self.state == "Run":
+            return
+        self.speed = .10
+        self.target = target
+        self.state = "Run"

Units/zombie.py

@@ -1,63 +0,0 @@
-import tkinter as tk
-import os
-import glob
-import time
-import random
-
-from Effects.animated_gif import AnimatedGif
-from Effects.order_click import OrderClick
-
-class Unit:
-    def __init__(self, engine, position=(0,0)):
-        self.engine = engine
-        self.position = position
-        self.target = position
-        self.script_name = os.path.basename(__file__).split('.')[0]
-        self.destination = position
-        gifs = glob.glob("assets/Zombie/**/*.gif", recursive=True)
-        self.animation = {os.path.basename(gif): AnimatedGif(gif) for gif in gifs}
-        self.state = "Walk"
-        self.speed = .05  # This is now the delay between updates in seconds
-        self.partial_move = 0
-        self.direction = 2
-        self.visited = [self.position]
-        self.starting_position = (position)
-        self.already_tried = []
-
-    def  move(self, target):
-        pass
-
-
-    def ai(self):
-        screen_x, screen_y = self.engine.iso_transform(*self.position)
-        if  self.position != self.target:
-            self.direction = self.engine.get_direction(self.position,self.destination)
-            if self.partial_move<1:
-                screen_x_dest, screen_y_dest = self.engine.iso_transform(*self.destination)
-                self.partial_move += self.speed
-                screen_x += (screen_x_dest - screen_x) * self.partial_move
-                screen_y += (screen_y_dest - screen_y) * self.partial_move
-            else:
-                screen_x, screen_y = self.engine.iso_transform(*self.destination)
-                neighbors_list = self.engine.find_neighbors(self.destination) # Get the neighbors of the destination cell
-                # Remove any neighbors that are not walkable
-                neighbors_list = [cell for cell in neighbors_list if self.engine.battlefield[cell[1]][cell[0]].walkable]
-                # Update position and visited list
-                self.position = self.destination
-                self.destination = None
-                self.visited.append(self.position)
-                self.destination = self.engine.get_closest_neighbor(neighbors_list,self.target)
-                self.partial_move = 0
-        else:
-            self.visited = [self.target]
-            self.position = self.target
-            self.starting_position = self.target
-            self.destination = self.target
-            self.state = "Idle"
-            self.partial_move = 1
-        gif = self.animation.get(f'{self.state}_dir{self.direction}.gif')
-        return gif, screen_x, screen_y
-    
-    def move_to(self, target):
-        self.target = target
-        self.state = "Walk"

main.py

@@ -1,18 +1,11 @@
 import time
-import tkinter as tk
 import glob
 import os
 import json
+import pyglet
 
-import Units
-
+from Units.knight import Knight
 from Effects.order_click import OrderClick
-from tkinter import Menu
-from collections import deque
-
-import Units.hound
-import Units.zombie
-
 
 
     
@@ -20,40 +13,59 @@ class IsometricGame:
     def __init__(self, width, height, data):
         self.width = width
         self.height = height
-        self.view_offset_x = 800
-        self.view_offset_y = 0
-        self.cell_width = 134
-        self.cell_height = 68
+        self.cell_width = 132
+        self.cell_height = 66
         self.cell_selected = (0, 0)
+        self.view_offset_x = 800
+        self.view_offset_y = 500
 
         self.last_trigger_time = 0
         self.min_interval = 0.5  # Minimum interval in seconds
         
         self.effects = []
+        # Create a window with a specific size and title
+        self.window = pyglet.window.Window(width=1920, height=1080, caption='Campo di Battaglia RTS Isometrico')
+        self.batch = pyglet.graphics.Batch()
+        @self.window.event
+        def on_draw():
+            self.window.clear()
+            self.draw_battlefield()
+
+        @self.window.event
+        def on_mouse_scroll(x, y, scroll_x, scroll_y):
+            # Adjust the view offset based on the scroll direction
+            self.view_offset_y += scroll_y * 70  # Adjust the multiplier as needed
+
         
         self.editor_mode = False
         self.input_lock = False
 
-        self.window = tk.Tk()
         files = sorted(glob.glob("Tiles/**/*.png", recursive=True))
-        self.tiles = {os.path.splitext(os.path.basename(file))[0]: tk.PhotoImage(file=file) for file in files}
+        self.tiles = {os.path.splitext(os.path.basename(file))[0]: pyglet.image.load(file) for file in files}
         # self.battlefield = [[Cell(walkable = True, tile=self.tiles["landscapeTiles_067"] ) for x in range(self.width)] for y in range(self.height)]
         # use data to create the battlefield
-        self.battlefield = [[Cell(walkable = not data[y][x], tile=self.tiles["landscapeTiles_067"] 
-                                  if not data[y][x] else self.tiles["landscapeTiles_066"]
-         ) for x in range(self.width)] for y in range(self.height)]
-        self.window.title("Campo di Battaglia RTS Isometrico")
-        
-        self.canvas = tk.Canvas(self.window, width=1920, height=1080, bg='black')
-        self.canvas.pack()
-        self.menu = Menu(self.canvas, tearoff=0)
-        self.window.bind('<KeyRelease>', self.on_key_press)
-        self.canvas.bind('<Button-1>', self.on_canvas_click)
-        self.canvas.bind('<Button-3>', self.on_canvas_rclick)
-        self.canvas.bind('<Motion>', self.calculate_coordinates)
-
-
-        self.knight = Units.zombie.Unit(self, position=(1, 1))
+        def create_sprite(tile, x, y):
+            print(x, y)
+            x,y= self.iso_transform(x, y)
+            print(x, y)
+            return pyglet.sprite.Sprite(tile, y=y, x=x)
+        self.battlefield = [[Cell(walkable = not data[row][column], sprite=create_sprite(tile=self.tiles["landscapeTiles_067"], y=(self.height-row), x=(self.width-column))
+                                  if not data[row][column] else create_sprite(tile=self.tiles["landscapeTiles_066"], y=(self.height-row), x=(self.width-column))
+         ) for column in range(self.width)] for row in range(self.height)]
+
+                # Crea lo sprite del tile, aggiungilo al batch (e al gruppo, se usato)
+                # sprite = pyglet.sprite.Sprite(img=tile_image, x=x, y=y, batch=batch)
+                # tile_sprites.append(sprite)
+        # self.canvas.pack()
+        # self.menu = Menu(self.canvas, tearoff=0)
+        # self.window.bind('<KeyRelease>', self.on_key_press)
+        # self.canvas.bind('<Button-1>', self.on_canvas_click)
+        # self.canvas.bind('<Button-3>', self.on_canvas_right_click)
+        # self.canvas.bind('<Double-Button-3>', self.on_canvas_double_right_click)
+        # self.canvas.bind('<Motion>', self.calculate_coordinates)
+
+
+        #self.knight = Knight(self, (1,1))
         self.draw_battlefield()
         
     def calculate_coordinates(self, event):
@@ -146,58 +158,20 @@ class IsometricGame:
         x1, y1 = position1
         x2, y2 = position2
         return abs(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5)
-    def get_distance_components(self, position1, position2):
-        x1, y1 = position1
-        x2, y2 = position2
-        return abs(x2 - x1), abs(y2 - y1)
-    #function to check if a cell is near a wall
-    def near_wall(self, position):
-        x, y = position
-        neighbors = self.find_neighbors(position)
-        for neighbor in neighbors:
-            if not self.battlefield[neighbor[1]][neighbor[0]].walkable:
-                return True
-    def min_steps_to_target(self, start, target):
-        grid = [[0 for _ in range(self.width)] for _ in range(self.height)]
-        rows, cols = len(grid), len(grid[0])
-        dx = [0, 1, 0, -1]
-        dy = [1, 0, -1, 0]
-        queue = deque([start])
-        visited = set([start])
-
-        steps = 0
-        while queue:
-            for _ in range(len(queue)):
-                x, y = queue.popleft()
-                if (x, y) == target:
-                    return steps
-
-                for i in range(4):
-                    nx, ny = x + dx[i], y + dy[i]
-                    if 0 <= nx < rows and 0 <= ny < cols and (nx, ny) not in visited:
-                        queue.append((nx, ny))
-                        visited.add((nx, ny))
-            steps += 1
-
-        return -1      
+    
     def draw_battlefield(self):
-        self.canvas.delete("cell")  # Pulisce le celle precedenti prima di ridisegnare
-        self.canvas.delete("cell-label") 
-        for y, row in enumerate(self.battlefield):
-            for x, cell in enumerate(row):
-                screen_x, screen_y = self.iso_transform(x, y)
-                offset = (99 - cell.tile.height()) / 2
-                self.canvas.create_image(screen_x, screen_y+45+offset, image=cell.tile, tags="cell")
-                if self.editor_mode:
-                    self.canvas.create_text(screen_x, screen_y+45, text=str(cell.elevation), tags="cell_label")
-                    self.canvas.create_text(screen_x+10, screen_y+45, text=str(int(cell.walkable)), tags="cell_label", fill="white" if cell.walkable else "red")
-                    self.canvas.create_text(screen_x+10, screen_y+35, text=str(int(cell.tile.height())), tags="cell_label", fill="white" if cell.walkable else "red")
+        for y, row in list(enumerate(self.battlefield)):
+            for x, cell in list(enumerate(row)):
+                cell.sprite.draw()
+                #self.canvas.create_image(screen_x, screen_y+45+offset, image=cell.tile, tags="cell")
                
     
     def draw_units(self):    
-        self.canvas.delete("unit")  # Pulisce le unità precedenti prima di ridisegnare        
         gif, screen_x, screen_y = self.knight.ai() # Calcola la posizione e l'animazione del cavaliere
-        self.canvas.create_image(screen_x, screen_y+35, image=gif.next_frame(), tags="unit") # Disegna il cavaliere
+        gif.x = screen_x - self.cell_width/2
+        gif.y = screen_y + height*3
+        gif.draw()
+        #self.canvas.create_image(screen_x, screen_y+35, image=gif.next_frame(), tags="unit") # Disegna il cavaliere
     
     def draw_effects(self):
         # Pulisce gli effetti precedenti prima di ridisegnare
@@ -273,11 +247,23 @@ class IsometricGame:
         # calculate the clicked cell's coordinates
         cell_x, cell_y = self.inv_iso_transform(event.x, event.y)
         self.battlefield[cell_y][cell_x].walkable ^= True
-        self.battlefield[cell_y][cell_x].tile = self.tiles["landscapeTiles_067"] if self.battlefield[cell_y][cell_x].walkable else self.tiles["landscapeTiles_066"]
         self.draw_battlefield()
         self.draw_units()
     
+    def on_canvas_right_click(self, event):
+        # calculate the clicked cell's coordinates
+        cell_x, cell_y = self.inv_iso_transform(event.x, event.y)
+        self.effects.append(OrderClick(self.iso_transform(cell_x, cell_y),color="lightblue"))
 
+        if 0 <= cell_x < self.width and 0 <= cell_y < self.height:
+            self.knight.move_to((cell_x, cell_y))
+
+    def on_canvas_double_right_click(self, event):
+        # calculate the clicked cell's coordinates
+        cell_x, cell_y = self.inv_iso_transform(event.x, event.y)
+        self.effects.append(OrderClick(self.iso_transform(cell_x, cell_y),color="darkblue"))
+        if 0 <= cell_x < self.width and 0 <= cell_y < self.height:
+            self.knight.run_to((cell_x, cell_y))
 
     def set_tile(self, name, pos):
         # Handle option 1 selection
@@ -289,34 +275,14 @@ class IsometricGame:
             self.draw_battlefield()
             
 
-    def on_canvas_rclick(self, event):
-        # calculate the clicked cell's coordinates
-        cell_x, cell_y = self.inv_iso_transform(event.x, event.y)
-        print(f'Cell clicked: ({cell_x}, {cell_y})')
-        x, y = self.iso_transform(cell_x, cell_y)
-        self.effects.append(OrderClick((x, y), color="light blue"))
-        if self.knight.target == (cell_x, cell_y):
-            return
-
-        if 0 <= cell_x < self.width and 0 <= cell_y < self.height:
-            self.knight.move_to((cell_x,cell_y))
-            
     def run(self):
-        self.draw_battlefield()
         self.update()
         self.window.mainloop()
 
-    def update(self):
-        #self.draw_battlefield()
-        self.draw_units()
-        self.draw_effects()
-        self.window.after(75, self.update)  # Call again after 100 ms
 
 class Cell:
-    def __init__(self, walkable=False, tile=None, elevation=0, offset=0):
-        self.tile = tile
-        
-        
+    def __init__(self, walkable=False, sprite=None, elevation=0, offset=0):
+        self.sprite = sprite
         self.walkable = walkable
         self.elevation = elevation
 
@@ -325,19 +291,8 @@ class Cell:
 if __name__ == "__main__":
     with open('maze.json', 'r') as file:
         data = json.load(file)
-    # Creare una matrice 10x10 piena di False
-    room = [[True for _ in range(10)] for _ in range(10)]
-
-    # Cambiare i valori interni della matrice in True
-    for i in range(1, 9):
-        for j in range(1, 8):
-            room[i][j] = False
-
-    # Creare un'apertura di un'unità verso l'esterno
-    room[0][4] = True  # Cambia questo valore per spostare l'apertura
-    data =room
     # data is a boolean matrix, find dmensions
     width = len(data[0])
     height = len(data)
     game = IsometricGame(width=width, height=height, data=data)
-    game.run()
+    pyglet.app.run()

maze.json

@@ -1 +1,7 @@
-[[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true], [true, false, false, false, false, false, true, false, false, false, false, false, true, false, false, false, true, false, false, false, true], [true, true, true, true, false, false, false, true, true, false, false, false, true, false, false, false, true, true, true, false, true], [true, false, false, false, false, false, true, false, false, false, true, false, true, false, true, false, true, false, false, false, true], [true, false, true, false, true, true, true, false, true, true, true, false, true, false, true, false, true, false, true, true, true], [true, false, false, false, true, false, false, false, true, false, true, false, true, false, true, false, true, false, false, false, true], [true, false, true, true, true, false, true, true, true, false, true, false, true, false, true, false, true, true, false, false, true], [true, false, true, false, false, false, true, false, false, false, false, false, true, false, true, false, false, false, true, false, true], [true, false, true, false, true, false, true, true, true, false, true, false, false, false, false, false, true, false, true, false, true], [true, false, true, false, true, false, false, false, true, false, true, false, true, false, false, false, false, false, true, false, true], [true, false, true, false, true, true, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true], [true, false, true, false, false, false, true, false, false, false, true, false, false, false, true, false, false, false, false, false, true], [true, false, true, true, true, true, true, false, true, false, true, true, true, true, true, false, false, true, true, false, true], [true, false, false, false, false, false, true, false, true, false, false, false, false, false, true, false, true, false, false, false, true], [true, false, true, false, true, false, true, false, true, true, false, true, true, false, true, false, true, true, true, true, true], [true, false, false, false, false, false, false, false, true, false, false, false, true, false, true, false, false, false, false, false, true], [true, false, true, false, true, true, true, true, true, false, false, false, true, false, true, true, true, true, false, false, true], [true, false, true, false, false, false, false, false, false, false, true, false, true, false, false, false, false, false, false, false, true], [true, false, true, true, true, true, true, false, true, false, true, true, true, true, true, false, false, false, true, false, true], [true, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, true], [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]]
+[
+  [true, true, true, true, true],
+  [true, false, true, false, true],
+  [true, false, false, false, true],
+  [true, false, false, false, true],
+  [true, true, true, true, true]
+]

maze.py

@@ -99,5 +99,5 @@ class MazeGenerator:
         self.window.mainloop()
 
 # Crea e avvia il generatore di labirinti
-generator = MazeGenerator(20, 20)
+generator = MazeGenerator(5, 5)
 generator.run()

solver.py

@@ -70,6 +70,5 @@ class MazeSolver:
         self.window.mainloop()
 
 # Create and run the maze solver
-        #Breadth-First Search, BFS
 solver = MazeSolver('maze.json')
 solver.run()