pyxora.assets

  1from .utils import engine,python
  2
  3from dataclasses import dataclass, field
  4from typing import Any,Optional
  5import os
  6
  7import pygame
  8
  9loaders = {
 10    "images":lambda path:pygame.image.load(path).convert_alpha(),
 11    "music": lambda path:path, # pygame.music loads only the last music file
 12    "sfx":lambda path:pygame.mixer.Sound(path),
 13    "fonts": lambda path: {size: pygame.font.Font(path, size) for size in
 14        {1, 2, 4, 8, 10, 12, 14, 16, 18, 24, 32, 48, 64, 72, 96, 128, 144, 192, 256}},
 15    "scenes": lambda path: python.load_class(path,python.get_filename(path).title().replace(" ", "_")),
 16    "scripts": lambda path: python.load_class(path,python.get_filename(path).title().replace(" ", "_"))
 17}
 18"""@private The loaders dictionary"""
 19
 20@dataclass
 21class Data:
 22    """The Data structure"""
 23    files: dict[str, dict[str, str]] = field(default_factory=dict)
 24    images: dict[str, Any] = field(default_factory=dict)
 25    fonts: dict[str, Any] = field(default_factory=dict)
 26    scenes: dict[str, Any] = field(default_factory=dict)
 27    scripts: dict[str, Any] = field(default_factory=dict)
 28    music: dict[str, Any] = field(default_factory=dict)
 29    sfx: dict[str, Any] = field(default_factory=dict)
 30
 31    def __repr__(self) -> str:
 32        return (
 33            f"<Loaded Data | "
 34            f"images: {len(self.images)}, "
 35            f"fonts: {len(self.fonts)}, "
 36            f"scenes: {len(self.scenes)}, "
 37            f"scripts: {len(self.scripts)}, "
 38            f"music: {len(self.music)}, "
 39            f"sfx: {len(self.sfx)}>"
 40        )
 41
 42class Assets:
 43    data = Data()
 44    """@private The game data"""
 45    engine = Data()
 46    """@private The Engine data"""
 47
 48    @classmethod
 49    def init(
 50        cls,
 51        path_images: str = None,path_fonts: str = None,
 52        path_scenes: str = None,path_scripts: str = None,
 53        path_music: str = None,path_sfx: str = None,
 54        pre_load: bool = True
 55    ) -> None:
 56        """
 57        Initialize the Assets system by loading asset files into the Data structure.
 58
 59        Args:
 60            path_images (str, optional): Path to image files.
 61            path_fonts (str, optional): Path to font files.
 62            path_scenes (str, optional): Path to scene files.
 63            path_scripts (str, optional): Path to script files.
 64            path_music (str, optional): Path to song files.
 65            path_sfx (str, optional): Path to sound effect files.
 66            pre_load (bool): Whether to preload the assets immediately. Defaults to True.
 67        """
 68        cls._load_engine_files()
 69        cls.load("engine") # always load the engine data
 70        cls.engine.fonts.update(cls.__get_default_font()) # add default font to engine
 71
 72        cls._load_data_files(
 73            path_images,path_fonts,
 74            path_scenes,path_scripts,
 75            path_music,path_sfx
 76        )
 77        pre_load and cls.load("data")
 78
 79    @classmethod
 80    def get(cls,source: str, *loc) -> Any:
 81        """
 82        Safely retrieve a nested value from a source dictionary.
 83
 84        Args:
 85            source (str): The data name to retrieve data from.
 86            *loc (str): A sequence of keys representing the path to the desired value.
 87
 88        Returns:
 89            Any: The value at the specified nested location, or None if the path is invalid.
 90
 91        Example:
 92            Assets.get("data"images", "player")  # Returns the player Surface if it exists
 93            Assets.get("engine,"images", "icon")  # Returns the engine icon Surface
 94        """
 95
 96        # return None if no location is provided
 97        # as having direct access to a dynamic attribute sounds scary lol
 98        if not loc:
 99            return None
100
101        source = getattr(cls, source)
102        target = loc[0]
103
104        data = getattr(source, target, None)
105        if data is None:
106            return None
107
108        for key in loc[1:]:
109            if not isinstance(data, dict):
110                return None
111            data = data.get(key)
112
113        return data
114
115    @classmethod
116    def load(cls, source: "str") -> None:
117        """
118        Load file paths into the data system
119
120        Args:
121            source (str): The data name to retrieve data from.
122        """
123
124        data = getattr(cls, source)
125        for category, loader in loaders.items():
126            file_dict = data.files.get(category)
127            if not file_dict:
128                continue
129
130            asset_store = getattr(data, category)
131            for name, path in file_dict.items():
132                asset_store[name] = loader(path)
133
134    @classmethod
135    def _load_data_files(cls,
136        path_images: str,path_fonts: str ,
137        path_scenes: str,path_scripts: str,
138        path_music: str,path_sfx: str) -> None:
139        """
140        This method scans each provided directory path and organizes the discovered files
141        into a structured dictionary (e.g., `Data.files`).
142
143        Args:
144            path_images (str): Path to image files.
145            path_fonts (str): Path to font files.
146            path_scenes (str): Path to scene files.
147            path_scripts (str): Path to script files.
148            path_music (str): Path to music files.
149            path_sfx (str): Path to sound effect files.
150        """
151
152
153        paths = {}
154        if path_images is not None:
155            paths["images"] = cls.__get_full_path(path_images)
156
157        if path_fonts is not None:
158            paths["fonts"] = cls.__get_full_path(path_fonts)
159
160        if path_music is not None:
161            paths["music"] = cls.__get_full_path(path_music)
162
163        if path_sfx is not None:
164            paths["sfx"] = cls.__get_full_path(path_sfx)
165
166        if path_scenes is not None:
167            paths["scenes"] = cls.__get_full_path(path_scenes)
168
169        if path_scripts is not None:
170            paths["scripts"] = cls.__get_full_path(path_scripts)
171
172        cls.data.files = cls.__get_all_files(paths)
173
174    @classmethod
175    def _load_engine_files(cls) -> None:
176        """Same as _load_data_files but for engine assets."""
177        base = os.path.dirname(__file__)
178        path_images = os.path.normpath(os.path.join(base,"data","images"))
179        paths = {
180            "images": path_images,
181            # More in the Future?
182            # Like basic build-in scripts to speed up development
183        }
184
185        cls.engine.files = cls.__get_all_files(paths)
186
187    @staticmethod
188    def __get_default_font() -> dict[str, dict[int, pygame.font.Font]]:
189        """
190        Loads the default system font in a variety of common sizes.
191
192        Returns:
193            dict[str, dict[int, pygame.font.Font]]:
194                A dictionary mapping the default font name to another dictionary
195                that maps font sizes to `pygame.font.Font` objects.
196        """
197        name = pygame.font.get_default_font().split(".")[0]
198        sizes = {
199            size: pygame.font.SysFont(name, size) for size in
200            {1, 2, 4, 8, 10, 12, 14, 16, 18, 24, 32, 48, 64, 72, 96, 128, 144, 192, 256}
201        }
202        return {name: sizes}
203
204    @staticmethod
205    def __get_all_files(path,ignore=None) -> dict[str, dict[str, str]]:
206        """
207        Recursively scan provided directories and build a nested dictionary of file paths.
208
209        Args:
210            path (dict[str, str]): A dictionary where each key is an asset type
211                                (like "images" or "fonts") and the value is the path to its folder.
212            ignore (set[str], optional): A set of folder names to exclude from scanning.
213                                        "__pycache__" is always ignored.
214
215        Returns:
216            dict[str, dict[str, str]]: A nested dictionary structured like:
217                {
218                    "images": {
219                        "player": "/path/to/images/player.png",
220                        "enemy": "/path/to/images/enemy.png"
221                    },
222                    "fonts": {
223                        "main": "/path/to/fonts/arial.ttf"
224                    },
225                    ...
226                }
227        """
228        if not ignore:
229            ignore = set()
230
231        ignore.update({"__pycache__"})
232
233        data = {}
234        for key,value in path.items():
235            for root, dirs, files in os.walk(value,topdown=False):
236                ftype = os.path.basename(root)
237                if ftype in ignore: continue
238                data[key] = {}
239                for file in files:
240                    full_path = os.path.join(root, file)
241                    name,_ = os.path.splitext(os.path.basename(full_path))
242                    data[key][name] = full_path
243
244        return data
245
246    @staticmethod
247    def __get_full_path(path):
248        """
249        Convert a relative path to an absolute normalized path and verify it exists.
250
251        Args:
252            path (str): The relative or partial path to validate.
253
254        Returns:
255            str: The normalized absolute path.
256
257        Raises:
258            OSError: If the resolved path does not exist.
259        """
260        path = os.path.normpath(os.getcwd()+path)
261        if not os.path.exists(path):
262            engine.error(OSError(f"The path doesn't exist: {path}"))
263            engine.quit()
264        return path