Fixed MG2 palette

Author: GrzybDev

src/mgtools/mg2/mappings.py

@@ -2,6 +2,15 @@
 
 DATA_TYPE_MAP = {}
 
+# Palette configuration for MG2 sprite sections.
+# Section 24 uses two large blocks: block 39 at index 0 (covers 0-90)
+# and block 37 at index 96 (covers 96-206).
+MG2_PALETTE_SECTION_24_BLOCKS: list[tuple[int, int]] = [(39, 0), (37, 96)]
+
+# Sections 25-45 each use a single palette block whose colours start at
+# this offset within the 256-entry palette.
+MG2_PALETTE_SPRITE_OFFSET: int = 192
+
 FILE_TYPE_MAP = {
     2: FileType.LOCALE,
     24: FileType.SPRITE,

src/mgtools/resource/assets/palette.py

@@ -41,6 +41,37 @@ def palette_bytes(self) -> bytes:
 
         return palette
 
+    @property
+    def block_count(self) -> int:
+        return len(self.__color_blocks)
+
+    def get_block_size(self, block_index: int) -> int:
+        return len(self.__color_blocks[block_index])
+
+    def build_palette_bytes(self, block_offsets: list[tuple[int, int]]) -> bytes:
+        """Build a 256-color RGB palette from specific blocks at given offsets.
+
+        Args:
+            block_offsets: List of (block_index, start_offset) pairs.
+                Each block's colors are placed starting at start_offset
+                in the 256-entry palette.
+
+        Returns:
+            768 bytes of RGB palette data (256 * 3).
+        """
+        palette: list[tuple[int, int, int]] = [(0, 0, 0)] * 256
+
+        for block_index, start_offset in block_offsets:
+            for i, color in enumerate(self.__color_blocks[block_index]):
+                idx = start_offset + i
+                if 0 <= idx < 256:
+                    palette[idx] = color
+
+        result = b""
+        for r, g, b in palette:
+            result += bytes([r, g, b])
+        return result
+
     def __init__(self, data_type: DataType) -> None:
         super().__init__(data_type)
         self.__colors: list[tuple[int, int, int]] = []

src/mgtools/resource/assets/sprite.py

@@ -105,7 +105,7 @@ def add_data(self, **kwargs) -> None:
 
             self.__variants.append(decode_sprite_entry(reader.read(data_length)))
 
-    def add_palette(self, palette: Palette) -> None:
+    def add_palette(self, palette: "Palette | bytes") -> None:
         apply_palette(self.__variants, palette)
 
     def export(self, output_path: Path, **kwargs) -> None:

src/mgtools/resource/file.py

@@ -219,7 +219,11 @@ def unpack(self, output_dir: Path, section_index: int, **kwargs) -> None:
         if isinstance(file, (Sprite, FramedSprite)):
             for section in self.__sections:
                 if isinstance(section, Palette):
-                    file.add_palette(section)
+                    if self.__game == Game.MG2:
+                        palette_bytes = self.__build_mg2_palette(section_index, section)
+                        file.add_palette(palette_bytes)
+                    else:
+                        file.add_palette(section)
                     break
 
         file_type = file_type_map.get(section_index, FileType.UNKNOWN)
@@ -243,6 +247,79 @@ def __get_file_type_map(self) -> dict:
             return MG2_FILE_TYPE_MAP
         raise ValueError(f"Unsupported game: {self.__game}")
 
+    def __build_mg2_palette(self, section_index: int, palette: Palette) -> bytes:
+        """Build a 256-color palette for a specific MG2 sprite section.
+
+        Section 24 uses a combined palette from two large blocks covering
+        indices 0-90 and 96-206. Sections 25-45 each use a single block
+        whose colors start at index 192.
+        """
+        from mgtools.mg2.mappings import (
+            MG2_PALETTE_SECTION_24_BLOCKS,
+            MG2_PALETTE_SPRITE_OFFSET,
+        )
+
+        if section_index == 24:
+            return palette.build_palette_bytes(MG2_PALETTE_SECTION_24_BLOCKS)
+
+        # Sections 25-45: find a palette block whose size matches the
+        # number of contiguous colour indices this section uses at 192+.
+        file_type_map = self.__get_file_type_map()
+        sprite_sections = sorted(
+            idx
+            for idx, ft in file_type_map.items()
+            if ft == FileType.SPRITE and idx != 24
+        )
+
+        # Determine how many colours this section needs
+        section_file = self.__sections[section_index]
+        needed = 0
+        if hasattr(section_file, "_Sprite__variants"):
+            all_unique: set[int] = set()
+            for v in section_file._Sprite__variants:  # type: ignore[attr-defined]
+                all_unique.update(v.tobytes())
+            needed = len([x for x in all_unique if x >= MG2_PALETTE_SPRITE_OFFSET])
+
+        # Reserve large blocks (section-24 group)
+        used: set[int] = set()
+        for bi, _ in MG2_PALETTE_SECTION_24_BLOCKS:
+            used.add(bi)
+        # Also reserve all blocks whose first colour is magenta (255,0,255)
+        # — these are section-24 palette components.
+        for bi in range(palette.block_count):
+            block_colors = palette._Palette__color_blocks[bi]  # type: ignore[attr-defined]
+            if block_colors and block_colors[0] == (255, 0, 255):
+                used.add(bi)
+
+        # Greedy first-fit: iterate over sprite sections in order (25-45).
+        # For each section, consume the first unused block with matching size.
+        assigned: dict[int, int] = {}
+        for sec in sprite_sections:
+            sec_file = self.__sections[sec]
+            sec_needed = 0
+            if hasattr(sec_file, "_Sprite__variants"):
+                sec_unique: set[int] = set()
+                for v in sec_file._Sprite__variants:  # type: ignore[attr-defined]
+                    sec_unique.update(v.tobytes())
+                sec_needed = len(
+                    [x for x in sec_unique if x >= MG2_PALETTE_SPRITE_OFFSET]
+                )
+            for bi in range(palette.block_count):
+                if bi in used:
+                    continue
+                if palette.get_block_size(bi) == sec_needed:
+                    assigned[sec] = bi
+                    used.add(bi)
+                    break
+
+        if section_index in assigned:
+            return palette.build_palette_bytes(
+                [(assigned[section_index], MG2_PALETTE_SPRITE_OFFSET)]
+            )
+
+        # Fallback: use the flat palette
+        return palette.palette_bytes
+
     def add_from_folder(self, input_dir: Path, section_index: int, **kwargs) -> None:
         if self.__game == Game.MG1:
             default_data_type = DataType.MG1_SECTION

src/mgtools/utilities/sprite.py

@@ -34,9 +34,12 @@ def decode_sprite_entry(data: bytes) -> Image.Image:
     return Image.frombytes("P", (width, height), pixel_data)
 
 
-def apply_palette(images: list[Image.Image], palette: Palette) -> None:
-    """Apply a Palette to every image in the list."""
-    palette_bytes = palette.palette_bytes
+def apply_palette(images: list[Image.Image], palette: "Palette | bytes") -> None:
+    """Apply a Palette (or raw palette bytes) to every image in the list."""
+    if isinstance(palette, bytes):
+        palette_bytes = palette
+    else:
+        palette_bytes = palette.palette_bytes
 
     for image in images:
         image.putpalette(palette_bytes)