Matrix Bank, Matrix2x3, Movie Clip rendering

Author: danila-schelkov

.gitignore

@@ -1,7 +1,15 @@
-/SC/
-/CSV/
-/updates/
+# IDE project files
 /.idea/
+/*.iml
+
+# Script folders
+/updates/
 /logs/
+/CSV/
+/SC/
+
+# Configuration files
 system/config.json
+
+# Python compiled files
 *.pyc

system/bytestream.py

@@ -1,64 +1,69 @@
 import io
+from typing import Literal
 
 
 class Reader(io.BytesIO):
-    def __init__(self, buffer: bytes = b'', endian: str = 'little'):
+    def __init__(self, buffer: bytes = b'', endian: Literal['little', 'big'] = 'little'):
         super().__init__(buffer)
+
         self.buffer = buffer
         self.endian = endian
 
-    def read_int(self, length: int, signed=False):
+    def read_integer(self, length: int, signed=False) -> int:
         return int.from_bytes(self.read(length), self.endian, signed=signed)
 
-    def read_ubyte(self):
-        return self.read_int(1)
+    def read_uchar(self) -> int:
+        return self.read_integer(1)
+
+    def read_char(self) -> int:
+        return self.read_integer(1, True)
 
-    def read_byte(self):
-        return self.read_int(1, True)
+    def read_ushort(self) -> int:
+        return self.read_integer(2)
 
-    def read_uint16(self):
-        return self.read_int(2)
+    def read_short(self) -> int:
+        return self.read_integer(2, True)
 
-    def read_int16(self):
-        return self.read_int(2, True)
+    def read_uint(self) -> int:
+        return self.read_integer(4)
 
-    def read_uint32(self):
-        return self.read_int(4)
+    def read_int(self) -> int:
+        return self.read_integer(4, True)
 
-    def read_int32(self):
-        return self.read_int(4, True)
+    def read_twip(self) -> float:
+        return self.read_int() / 20
 
-    def read_string(self):
-        length = self.read_ubyte()
+    def read_string(self) -> str:
+        length = self.read_uchar()
         if length != 255:
             return self.read(length).decode()
         return ''
 
 
 class Writer(io.BytesIO):
-    def __init__(self, endian: str = 'little'):
+    def __init__(self, endian: Literal['little', 'big'] = 'little'):
         super().__init__()
         self.endian = endian
 
-    def write_int(self, integer, length: int = 1, signed: bool = False):
+    def write_int(self, integer: int, length: int = 1, signed: bool = False):
         self.write(integer.to_bytes(length, self.endian, signed=signed))
 
-    def write_ubyte(self, integer):
+    def write_ubyte(self, integer: int):
         self.write_int(integer)
 
-    def write_byte(self, integer):
+    def write_byte(self, integer: int):
         self.write_int(integer, signed=True)
 
-    def write_uint16(self, integer):
+    def write_uint16(self, integer: int):
         self.write_int(integer, 2)
 
-    def write_int16(self, integer):
+    def write_int16(self, integer: int):
         self.write_int(integer, 2, True)
 
-    def write_uint32(self, integer):
+    def write_uint32(self, integer: int):
         self.write_int(integer, 4)
 
-    def write_int32(self, integer):
+    def write_int32(self, integer: int):
         self.write_int(integer, 4, True)
 
     def write_string(self, string: str = None):

system/lib/__init__.py

@@ -14,13 +14,13 @@
 
 logger.remove()
 logger.add(
-    './logs/info/{time:YYYY-DD-MM}.log',
+    './logs/info/{time:YYYY-MM-DD}.log',
     format='[{time:HH:mm:ss}] [{level}]: {message}',
     encoding="utf8",
     level='INFO'
 )
 logger.add(
-    './logs/errors/{time:YYYY-DD-MM}.log',
+    './logs/errors/{time:YYYY-MM-DD}.log',
     format='[{time:HH:mm:ss}] [{level}]: {message}',
     backtrace=True,
     diagnose=True,
@@ -34,6 +34,7 @@
 
 
 try:
+    # noinspection PyUnresolvedReferences
     import requests
     del requests
 
@@ -58,6 +59,7 @@
     pass
 
 
+# noinspection PyUnresolvedReferences
 @logger.catch()
 def refill_menu():
     menu.categories.clear()
@@ -73,10 +75,10 @@ def refill_menu():
             import PIL
             del PIL
 
-            from system.lib.features.sc.assembly_encode import sc1_encode
             from system.lib.features.sc.decode import sc_decode
-            from system.lib.features.sc.decode_and_cut import sc1_decode
-            from system.lib.features.sc.sc_encode import sc_encode
+            from system.lib.features.sc.encode import sc_encode
+            from system.lib.features.sc.decode_and_cut import decode_and_cut
+            from system.lib.features.sc.assembly_encode import sc1_encode
 
             sc_category = Menu.Category(0, locale.sc_label)
             sc_category.add(Menu.Item(
@@ -92,7 +94,7 @@ def refill_menu():
             sc_category.add(Menu.Item(
                 locale.decode_by_parts,
                 locale.decode_by_parts_description,
-                sc1_decode
+                decode_and_cut
             ))
             sc_category.add(Menu.Item(
                 locale.encode_by_parts,

system/lib/features/cut_sprites.py

@@ -8,22 +8,55 @@
 def cut_sprites(swf: SupercellSWF, export_folder: str):
     os.makedirs(f'{export_folder}/overwrite', exist_ok=True)
     os.makedirs(f'{export_folder}/shapes', exist_ok=True)
+    os.makedirs(f'{export_folder}/movie_clips', exist_ok=True)
+
+    # TODO: Too slow, fix it
+    # movie_clips_skipped = 0
+    # movie_clip_count = len(swf.movie_clips)
+    # for movie_clip_index in range(movie_clip_count):
+    #     movie_clip = swf.movie_clips[movie_clip_index]
+    #
+    #     rendered_movie_clip = movie_clip.render(swf)
+    #     if sum(rendered_movie_clip.size) >= 2:
+    #         rendered_movie_clip.save(f'{export_folder}/movie_clips/{movie_clip.export_name or movie_clip.id}.png')
+    #     else:
+    #         # For debug:
+    #         # logger.warning(f'MovieClip {movie_clip.id} cannot be rendered.')
+    #         movie_clips_skipped += 1
+    #
+    #     Console.progress_bar(
+    #         'Rendering movie clips (%d/%d). Skipped count: %d' %
+    #         (movie_clip_index + 1, movie_clip_count, movie_clips_skipped),
+    #         movie_clip_index,
+    #         movie_clip_count
+    #     )
 
     shapes_count = len(swf.shapes)
     swf.xcod_writer.write_uint16(shapes_count)
 
     for shape_index in range(shapes_count):
+        shape = swf.shapes[shape_index]
+
         Console.progress_bar(
             locale.cut_sprites_process % (shape_index + 1, shapes_count),
             shape_index,
             shapes_count
         )
 
-        shape = swf.shapes[shape_index]
-
-        rendered_shape = shape.render(swf)
+        rendered_shape = shape.render()
         rendered_shape.save(f'{export_folder}/shapes/{shape.id}.png')
 
+        regions_count = len(shape.regions)
+        for region_index in range(regions_count):
+            region = shape.regions[region_index]
+
+            region.apply_matrix(None)
+            rendered_region = region.render()
+            rendered_region.save(f'{export_folder}/shape_{shape.id}_{region_index}.png')
+
+    for shape_index in range(shapes_count):
+        shape = swf.shapes[shape_index]
+
         regions_count = len(shape.regions)
         swf.xcod_writer.write_uint16(shape.id)
         swf.xcod_writer.write_uint16(regions_count)
@@ -38,6 +71,3 @@ def cut_sprites(swf: SupercellSWF, export_folder: str):
                 swf.xcod_writer.write_uint16(int(region.get_v(i)))
             swf.xcod_writer.write_ubyte(1 if region.is_mirrored else 0)
             swf.xcod_writer.write_byte(region.rotation // 90)
-
-            rendered_region = region.render(swf)
-            rendered_region.save(f'{export_folder}/shape_{shape.id}_{region_index}.png')

system/lib/features/place_sprites.py

@@ -24,17 +24,17 @@ def place_sprites(xcod_path: str, folder: str, overwrite: bool = False) -> (list
             Image.new(get_format_by_pixel_type(sheet_info.pixel_type), sheet_info.size)
         )
 
-    shapes_count = xcod.read_uint16()
+    shapes_count = xcod.read_ushort()
     for shape_index in range(shapes_count):
         Console.progress_bar(locale.place_sprites_process % (shape_index + 1, shapes_count), shape_index, shapes_count)
-        shape_id = xcod.read_uint16()
+        shape_id = xcod.read_ushort()
 
-        regions_count = xcod.read_uint16()
+        regions_count = xcod.read_ushort()
         for region_index in range(regions_count):
-            texture_id, points_count = xcod.read_ubyte(), xcod.read_ubyte()
+            texture_id, points_count = xcod.read_uchar(), xcod.read_uchar()
             texture_width, texture_height = sheets[texture_id].width, sheets[texture_id].height
-            polygon = [(xcod.read_uint16(), xcod.read_uint16()) for _ in range(points_count)]
-            mirroring, rotation = xcod.read_ubyte() == 1, xcod.read_byte() * 90
+            polygon = [(xcod.read_ushort(), xcod.read_ushort()) for _ in range(points_count)]
+            mirroring, rotation = xcod.read_uchar() == 1, xcod.read_char() * 90
 
             filename = f'shape_{shape_id}_{region_index}.png'
             if filename not in files_to_overwrite:

system/lib/features/sc/decode_and_cut.py

@@ -8,7 +8,7 @@
 from system.localization import locale
 
 
-def sc1_decode():
+def decode_and_cut():
     input_folder = './SC/In-Compressed'
     output_folder = './SC/Out-Sprites'
     files = os.listdir(input_folder)

system/lib/features/sc/sc_encode.py renamed to system/lib/features/sc/encode.py

@@ -0,0 +1,40 @@
+from typing import List, Tuple
+
+from system.lib.objects.point import Point
+
+
+def get_size(left: float, top: float, right: float, bottom: float) -> (int, int):
+    """Returns width and height of given rect.
+
+    :param left: left side of polygon
+    :param top: top side of polygon
+    :param right: right side of polygon
+    :param bottom: bottom side of polygon
+    :return: width, height
+    """
+    return int(right - left), int(bottom - top)
+
+
+def get_sides(points: List[Tuple[float, float]] or List[Point]) -> (float, float, float, float):
+    """Calculates and returns rect sides.
+
+    :param points: polygon points
+    :return: left, top, right, bottom
+    """
+    if len(points) > 0:
+        point = points[0]
+        if isinstance(point, Point):
+            left = min(point.x for point in points)
+            top = min(point.y for point in points)
+            right = max(point.x for point in points)
+            bottom = max(point.y for point in points)
+        elif isinstance(point, tuple):
+            left = min(x for x, _ in points)
+            top = min(y for _, y in points)
+            right = max(x for x, _ in points)
+            bottom = max(y for _, y in points)
+        else:
+            raise TypeError('Unknown point type.')
+
+        return left, top, right, bottom
+    raise ValueError('Empty points list.')

system/lib/helper.py

@@ -108,31 +108,31 @@ def load_texture(data: Reader, _type, img):
     channels_count = 4
     if _type in (0, 1):
         def read_pixel():
-            return data.read_ubyte(), data.read_ubyte(), data.read_ubyte(), data.read_ubyte()
+            return data.read_uchar(), data.read_uchar(), data.read_uchar(), data.read_uchar()
     elif _type == 2:
         def read_pixel():
-            p = data.read_uint16()
+            p = data.read_ushort()
             return (p >> 12 & 15) << 4, (p >> 8 & 15) << 4, (p >> 4 & 15) << 4, (p >> 0 & 15) << 4
     elif _type == 3:
         def read_pixel():
-            p = data.read_uint16()
+            p = data.read_ushort()
             return (p >> 11 & 31) << 3, (p >> 6 & 31) << 3, (p >> 1 & 31) << 3, (p & 255) << 7
     elif _type == 4:
         channels_count = 3
 
         def read_pixel():
-            p = data.read_uint16()
+            p = data.read_ushort()
             return (p >> 11 & 31) << 3, (p >> 5 & 63) << 2, (p & 31) << 3
     elif _type == 6:
         channels_count = 2
 
         def read_pixel():
-            return (data.read_ubyte(), data.read_ubyte())[::-1]
+            return (data.read_uchar(), data.read_uchar())[::-1]
     elif _type == 10:
         channels_count = 1
 
         def read_pixel():
-            return data.read_ubyte()
+            return data.read_uchar()
 
     if read_pixel is None:
         return