Aggiorna la gestione dei tasti e aggiungi nuovi file di configurazione per le schermate di pausa e menu di avvio

conf/keybinding_game.json

@@ -1,5 +1,5 @@
 {
-    "quit": ["Q", 12],
+
     "new_rat": ["Return", 13],
     "kill_rat": ["D"],
     "toggle_audio": ["M"],

conf/keybinding_paused.json

@@ -0,0 +1,6 @@
+{
+    
+    "reset_game": ["Return", 13],
+    "pause": ["P", 16],
+    "quit": ["Q", 12]
+}

conf/keybinding_start_menu.json

@@ -0,0 +1,5 @@
+{
+    
+    "start_game": ["Return", 13],
+    "quit": ["Q", 12]
+}

engine/controls.py

@@ -5,31 +5,43 @@ import random
 
 class KeyBindings:
     def key_pressed(self, key, coords=None):
-        if key in self.keybindings["quit"]:
+        keybindings = self.configs[f"keybinding_{self.game_status}"]
+        if key in keybindings.get("quit", []):
             self.engine.close()
-        elif key in self.keybindings["new_rat"]:
+        elif key in keybindings.get("new_rat", []):
             self.new_rat()
-        elif key in self.keybindings["kill_rat"]:
+        elif key in keybindings.get("kill_rat", []):
             if self.units:
                 self.units[random.choice(list(self.units.keys()))].die(score=5)
-        elif key in self.keybindings["toggle_audio"]:
+        elif key in keybindings.get("toggle_audio", []):
             self.audio = not self.audio
-        elif key in self.keybindings["toggle_full_screen"]:
+        elif key in keybindings.get("toggle_full_screen", []):
             self.full_screen = not self.full_screen
             self.engine.full_screen(self.full_screen)
-        elif key in self.keybindings["scroll_up"]:
+        elif key in keybindings.get("scroll_up", []):
             self.start_scrolling("Up")
-        elif key in self.keybindings["scroll_down"]:
+        elif key in keybindings.get("scroll_down", []):
             self.start_scrolling("Down")
-        elif key in self.keybindings["scroll_left"]:
+        elif key in keybindings.get("scroll_left", []):
             self.start_scrolling("Left")
-        elif key in self.keybindings["scroll_right"]:
+        elif key in keybindings.get("scroll_right", []):
             self.start_scrolling("Right")
-        elif key in self.keybindings["spawn_bomb"]:
+        elif key in keybindings.get("spawn_bomb", []):
             self.play_sound("PUTDOWN.WAV", tag="effects")
             self.spawn_bomb(self.pointer)
-        elif key in self.keybindings["pause"]:
-            self.pause = not self.pause
+        elif key in keybindings.get("pause", []):
+            self.game_status = "paused" if self.game_status == "game" else "game"
+        elif key in keybindings.get("start_game", []):
+            self.pause = False
+            self.game_status = "game"
+            self.start_game()
+        elif key in keybindings.get("reset_game", []):
+            self.pause = False
+            self.game_status = "game"
+            self.game_end = (False, None)
+            self.units.clear()
+            self.points = 0
+            self.start_game()
             
     def quit_game(self):
         self.engine.close()

engine/sdl2.py

@@ -14,7 +14,7 @@ class GameWindow:
         self.cell_size = cell_size
         self.width = width * cell_size
         self.height = height * cell_size
-        actual_screen_size = os.environ.get("RESOLUTIONz", "640x480").split("x")
+        actual_screen_size = os.environ.get("RESOLUTION", "640x480").split("x")
         actual_screen_size = tuple(map(int, actual_screen_size))
         self.target_size = actual_screen_size if self.width > actual_screen_size[0] or self.height > actual_screen_size[1] else (self.width, self.height)
         self.w_start_offset = (self.target_size[0] - self.width) // 2
@@ -119,6 +119,8 @@ class GameWindow:
         self.draw_rectangle(50, 50,
                             self.target_size[0] - 100, self.target_size[1] - 100, "win", filling=(255, 255, 255))
         self.draw_text(text, self.fonts[self.target_size[1]//20], "center", sdl2.ext.Color(0, 0, 0))
+        if subtitle := kwargs.get("subtitle"):
+            self.draw_text(subtitle, self.fonts[self.target_size[1]//30], (self.target_size[0] // 2 - 50, self.target_size[1] // 2 + 50), sdl2.ext.Color(0, 0, 0))
         if image := kwargs.get("image"):
             image_size = self.get_image_size(image)
             self.draw_image(self.target_size[0] // 2 - image_size[0] // 2 - self.w_offset,
@@ -130,6 +132,7 @@ class GameWindow:
             sprite.position = (self.target_size[0] // 2 - 50, self.target_size[1] // 2 + 30)
             self.renderer.copy(sprite, dstrect=sprite.position)
             for i, score in enumerate(scores[:5]):
+                score = " - ".join(score)
                 #self.draw_text(score, self.fonts[self.target_size[1]//40], (self.target_size[0] // 2 - 50, self.target_size[1] // 2 + 50 + 30 * (i + 1)), sdl2.ext.Color(0, 0, 0))
                 sprite_score = self.factory.from_text(score, color=sdl2.ext.Color(0, 0, 0), fontmanager=self.fonts[self.target_size[1]//40])
                 sprite_score.position = (self.target_size[0] // 2 - 50-sprite_score.size[0] // 4,
@@ -230,7 +233,6 @@ class GameWindow:
         self.h_offset = y
         
     def play_sound(self, sound_file, tag="base"):
-        print(sound_file)
         sound_file = os.path.join("sound", sound_file)
         rw = sdl2.SDL_RWFromFile(byteify(sound_file, "utf-8"), b"rb")
         if not rw:
@@ -257,9 +259,9 @@ class GameWindow:
                 sdl2.SDL_ClearQueuedAudio(dev[1])
                 
     def start_dialog(self, **kwargs):
-        self.dialog("Welcome to the Mice!", **kwargs)
+        self.dialog("Welcome to the Mice!", subtitle="A game by Matteo because was bored", **kwargs)
         center = self.get_view_center()
-        self.draw_button(center[0], center[1] + 10 * self.scale, "Start", 120, 50, (0, 0))
+        #self.draw_button(center[0], center[1] + 10 * self.scale, "Start", 120, 50, (0, 0))
         
     def draw_button(self, x, y, text, width, height, coords):
         if self.button_cursor[0] == coords[0] and self.button_cursor[1] == coords[1]:

rats.py

@@ -6,7 +6,6 @@ import uuid
 from engine import maze, sdl2 as engine, controls
 import os
 import datetime
-import subprocess
 import json
 
 class MiceMaze(controls.KeyBindings):
@@ -26,17 +25,22 @@ class MiceMaze(controls.KeyBindings):
         self.unit_positions = {}
         self.unit_positions_before = {}
         self.scrolling_direction = None
-        self.pause = False
+        self.game_status = "start_menu"
         self.game_end = (False, None)
-        self.dialog = "start_menu"
         self.scrolling = False
         self.sounds = {}
         self.start_game()
         self.background_texture = None
-        keybindings_file, = "keybinding_game.json",
-        with open(os.path.join("conf", keybindings_file)) as f:
-            self.keybindings = json.load(f)
+        self.configs = self.get_config()
         
+    def get_config(self):
+        configs = {}
+        for file in os.listdir("conf"):
+            if file.endswith(".json"):
+                with open(os.path.join("conf", file)) as f:
+                    configs[file[:-5]] = json.load(f)
+        return configs
+    
     def start_game(self):
         for _ in range(5):
             self.new_rat()
@@ -91,15 +95,19 @@ class MiceMaze(controls.KeyBindings):
                 
                 
             return True
+        
         if self.count_rats() > 200:
             self.stop_sound()
             self.play_sound("WEWIN.WAV")
             self.game_end = (True, False)
+            self.game_status = "paused"
             return True
         if not len(self.units):
             self.stop_sound()
             self.play_sound("VICTORY.WAV")
+            self.play_sound("WELLDONE.WAV", tag="effects")
             self.game_end = (True, True)
+            self.game_status = "paused"
             self.save_score()
             return True
         
@@ -108,17 +116,23 @@ class MiceMaze(controls.KeyBindings):
             f.write(f"{datetime.datetime.now()} - {self.points}\n")
     
     def read_score(self):
+        table = []
         with open("scores.txt") as f:
-            return f.read().splitlines()
+            rows = f.read().splitlines()
+            for row in rows:
+                table.append(row.split(" - "))
+            table.sort(key=lambda x: int(x[1]), reverse=True)
+        return table
             
     def update_maze(self):
-        if self.pause:
-            if self.dialog != "start_menu":
-                self.engine.dialog("Pause")
-            self.engine.start_dialog(image=self.assets["BMP_WEWIN"])
-            return
         if self.game_over():
             return
+        if self.game_status == "paused":
+            self.engine.dialog("Pause")
+            return
+        if self.game_status == "start_menu":
+            self.engine.dialog("Welcome to the Mice!", subtitle="A game by Matteo because he was bored",image=self.assets["BMP_WEWIN"])
+            return
         self.engine.delete_tag("unit")
         self.engine.delete_tag("effect")
         self.engine.draw_pointer(self.pointer[0] * self.cell_size, self.pointer[1] * self.cell_size)
@@ -149,21 +163,11 @@ class MiceMaze(controls.KeyBindings):
         )
         self.engine.scroll_view(self.pointer)
 
-    def play_sound(self, sound_file,tag="main"):
-        self.engine.play_sound(sound_file)
-        return
-        if self.audio:
-            if len(self.sounds) > 5:
-                self.sounds.pop(next(iter(self.sounds))).kill()
-            self.sounds[f"{tag}_{random.random()}"] = subprocess.Popen(["aplay", f"sound/{sound_file}"])
+    def play_sound(self, sound_file,tag="base"):
+        self.engine.play_sound(sound_file, tag=tag)
     
     def stop_sound(self, tag=None):
         self.engine.stop_sound()
-        return
-        for key, value in self.sounds.copy().items():
-            if tag is None or tag in key:
-                value.kill()
-                del self.sounds[key]
 
     def graphics_load(self):
         self.tunnel = self.engine.load_image("Rat/BMP_TUNNEL.png", surface=True)
@@ -180,6 +184,7 @@ class MiceMaze(controls.KeyBindings):
         for file in os.listdir("assets/Rat"):
             if file.endswith(".png"):
                 self.assets[file[:-4]] = self.engine.load_image(f"Rat/{file}")
+                
     def add_point(self, value):
         self.points += value