Merge remote-tracking branch 'github-desktop-Yura3313/master' into pr/1

Author: danila-schelkov

system/lib/features/files.py

@@ -25,7 +25,7 @@ def write_sc(output_filename: str, buffer: bytes, use_lzham: bool):
 
 
 def open_sc(input_filename: str):
-    decompressed = None
+    decompressed_data = None
     use_lzham = False
 
     logger.info(locale.collecting_inf)
@@ -36,7 +36,7 @@ def open_sc(input_filename: str):
     try:
         if b'START' in file_data:
             file_data = file_data[:file_data.index(b'START')]
-        decompressed, signature = decompress(file_data)
+        decompressed_data, signature = decompress(file_data)
         #
         # logger.info(locale.detected_comp % signature.upper())
         #
@@ -46,4 +46,4 @@ def open_sc(input_filename: str):
         logger.info(locale.decompression_error)
         exit(1)
 
-    return decompressed, use_lzham
+    return decompressed_data, use_lzham

system/lib/features/sc/__init__.py

@@ -7,7 +7,7 @@
 from system.bytestream import Writer
 from system.lib.console import Console
 from system.lib.features.files import write_sc
-from system.lib.images import get_pixel_size, split_image, rgba2bytes
+from system.lib.images import get_pixel_size, split_image, save_texture
 from system.lib.xcod import FileInfo
 from system.localization import locale
 
@@ -58,7 +58,7 @@ def compile_sc(_dir, file_info: FileInfo, sheets: list = None, output_folder: st
             split_image(img)
             print()
 
-        rgba2bytes(sc, img, pixel_type)
+        save_texture(sc, img, pixel_type)
         print()
 
     sc.write(bytes(5))

system/lib/features/sc/decode.py

@@ -14,35 +14,30 @@ def sc_decode():
 
     files = os.listdir(folder)
     for file in files:
-        if file.endswith('.sc'):
-            swf = SupercellSWF()
-            base_name = os.path.basename(file).rsplit('.', 1)[0]
-            try:
-                has_texture, use_lzham = swf.load_internal(f'{folder}/{file}', file.endswith('_tex.sc'))
-
-                if not has_texture:
-                    base_name += '_tex'
-                    file = base_name + '.sc'
-                    if file in files:
-                        files.remove(file)
-
-                        has_texture, use_lzham = swf.load_internal(f'{folder}/{file}', True)
-                    else:
-                        continue
-
-                current_sub_path = file[::-1].split('.', 1)[1][::-1]
-                if os.path.isdir(f'{folder_export}/{current_sub_path}'):
-                    shutil.rmtree(f'{folder_export}/{current_sub_path}')
-                os.mkdir(f'{folder_export}/{current_sub_path}')
-
-                data = struct.pack('4s?B', b'XCOD', use_lzham, len(swf.textures)) + swf.xcod_writer.getvalue()
-
-                with open(f'{folder_export}/{current_sub_path}/{base_name.rstrip("_")}.xcod', 'wb') as xc:
-                    xc.write(data)
-                for img_index in range(len(swf.textures)):
-                    filename = base_name + '_' * img_index
-                    swf.textures[img_index].image.save(f'{folder_export}/{current_sub_path}/{filename}.png')
-            except Exception as exception:
-                logger.exception(locale.error % (exception.__class__.__module__, exception.__class__.__name__, exception))
-
-            print()
+        if not file.endswith('.sc') or file.endswith('_tex.sc'):
+            continue
+
+        swf = SupercellSWF()
+        base_name = os.path.basename(file).rsplit('.', 1)[0]
+        try:
+            texture_loaded, use_lzham = swf.load(f'{folder}/{file}')
+
+            if not texture_loaded:
+                continue
+
+            current_sub_path = os.path.basename(swf.filename).rsplit('.', 1)[0]
+            if os.path.isdir(f'{folder_export}/{current_sub_path}'):
+                shutil.rmtree(f'{folder_export}/{current_sub_path}')
+            os.mkdir(f'{folder_export}/{current_sub_path}')
+
+            data = struct.pack('4s?B', b'XCOD', use_lzham, len(swf.textures)) + swf.xcod_writer.getvalue()
+
+            with open(f'{folder_export}/{current_sub_path}/{base_name.rstrip("_")}.xcod', 'wb') as xc:
+                xc.write(data)
+            for img_index in range(len(swf.textures)):
+                filename = base_name + '_' * img_index
+                swf.textures[img_index].image.save(f'{folder_export}/{current_sub_path}/{filename}.png')
+        except Exception as exception:
+            logger.exception(locale.error % (exception.__class__.__module__, exception.__class__.__name__, exception))
+
+        print()

system/lib/features/sc/decode_and_cut.py

@@ -9,59 +9,58 @@
 
 
 def sc1_decode():
-    folder = './SC/In-Compressed'
-    folder_export = './SC/Out-Sprites'
-    files = os.listdir(folder)
+    input_folder = './SC/In-Compressed'
+    output_folder = './SC/Out-Sprites'
+    files = os.listdir(input_folder)
 
     for file in files:
-        if not file.endswith('_tex.sc'):
-            xcod_file = None
-            try:
-                base_name = os.path.basename(file).rsplit('.', 1)[0]
+        if file.endswith('_tex.sc'):
+            continue
 
-                logger.info(locale.dec_sc)
-
-                swf = SupercellSWF()
-                has_texture, use_lzham = swf.load_internal(f'{folder}/{file}', False)
-                if not has_texture:
-                    file = base_name + '_tex.sc'
-                    if file not in files:
-                        logger.error(locale.not_found % file)
-                        continue
-                    _, use_lzham = swf.load_internal(f'{folder}/{file}', True)
+        xcod_file = None
+        try:
+            base_name = os.path.basename(file).rsplit('.', 1)[0]
 
-                current_sub_path = file[::-1].split('.', 1)[1][::-1]
-                if os.path.isdir(f'{folder_export}/{current_sub_path}'):
-                    shutil.rmtree(f'{folder_export}/{current_sub_path}')
-                os.mkdir(f'{folder_export}/{current_sub_path}')
-                os.makedirs(f"{folder_export}/{current_sub_path}/textures", exist_ok=True)
-                base_name = os.path.basename(file).rsplit('.', 1)[0]
+            logger.info(locale.dec_sc)
 
-                with open(f'{folder_export}/{current_sub_path}/{base_name}.xcod', 'wb') as xcod_file:
-                    xcod_file.write(b'XCOD' + bool.to_bytes(use_lzham, 1, 'big') +
-                                    int.to_bytes(len(swf.textures), 1, 'big'))
+            swf = SupercellSWF()
+            texture_loaded, use_lzham = swf.load(f'{input_folder}/{file}')
+            if not texture_loaded:
+                logger.error(locale.not_found % (base_name + '_tex.sc'))
+                continue
 
-                    for img_index in range(len(swf.textures)):
-                        filename = base_name + '_' * img_index
-                        swf.textures[img_index].image.save(
-                            f'{folder_export}/{current_sub_path}/textures/{filename}.png'
-                        )
+            current_sub_path = os.path.basename(swf.filename).rsplit('.', 1)[0]
+            if os.path.isdir(f'{output_folder}/{current_sub_path}'):
+                shutil.rmtree(f'{output_folder}/{current_sub_path}')
+            os.mkdir(f'{output_folder}/{current_sub_path}')
+            os.makedirs(f"{output_folder}/{current_sub_path}/textures", exist_ok=True)
+            base_name = os.path.basename(file).rsplit('.', 1)[0]
 
-                    logger.info(locale.dec_sc)
+            with open(f'{output_folder}/{current_sub_path}/{base_name}.xcod', 'wb') as xcod_file:
+                xcod_file.write(b'XCOD' + bool.to_bytes(use_lzham, 1, 'big') +
+                                int.to_bytes(len(swf.textures), 1, 'big'))
 
-                    cut_sprites(
-                        swf,
-                        f'{folder_export}/{current_sub_path}'
+                for img_index in range(len(swf.textures)):
+                    filename = base_name + '_' * img_index
+                    swf.textures[img_index].image.save(
+                        f'{output_folder}/{current_sub_path}/textures/{filename}.png'
                     )
-                    xcod_file.write(swf.xcod_writer.getvalue())
-            except Exception as exception:
-                if xcod_file is not None:
-                    xcod_file.close()
 
-                logger.exception(locale.error % (
-                    exception.__class__.__module__,
-                    exception.__class__.__name__,
-                    exception
-                ))
+                logger.info(locale.dec_sc)
+
+                cut_sprites(
+                    swf,
+                    f'{output_folder}/{current_sub_path}'
+                )
+                xcod_file.write(swf.xcod_writer.getvalue())
+        except Exception as exception:
+            if xcod_file is not None:
+                xcod_file.close()
+
+            logger.exception(locale.error % (
+                exception.__class__.__module__,
+                exception.__class__.__name__,
+                exception
+            ))
 
-            print()
+        print()

system/lib/images.py

@@ -30,33 +30,22 @@ def join_image(img):
 
         x_chunks_count = width // chunk_size
         y_chunks_count = height // chunk_size
-        x_rest = width % chunk_size
-        y_rest = height % chunk_size
 
-        for y_chunk in range(y_chunks_count):
-            for x_chunk in range(x_chunks_count):
+        for y_chunk in range(y_chunks_count + 1):
+            for x_chunk in range(x_chunks_count + 1):
                 for y in range(chunk_size):
+                    pixel_y = y_chunk * chunk_size + y
+                    if pixel_y >= height:
+                        break
+
                     for x in range(chunk_size):
-                        loaded_img[x_chunk * chunk_size + x, y_chunk * chunk_size + y] = tuple(
-                            pixel_buffer.read(channels_count)
-                        )
+                        pixel_x = x_chunk * chunk_size + x
+                        if pixel_x >= width:
+                            break
 
-            for y in range(chunk_size):
-                for x in range(x_rest):
-                    loaded_img[(width - x_rest) + x, y_chunk * chunk_size + y] = tuple(
-                        pixel_buffer.read(channels_count)
-                    )
-            Console.progress_bar(locale.join_pic, y_chunk, y_chunks_count)
-        for x_chunk in range(x_chunks_count):
-            for y in range(y_rest):
-                for x in range(chunk_size):
-                    loaded_img[x_chunk * chunk_size + x, (height - y_rest) + y] = tuple(
-                        pixel_buffer.read(channels_count)
-                    )
+                        loaded_img[pixel_x, pixel_y] = tuple(pixel_buffer.read(channels_count))
 
-        for y in range(y_rest):
-            for x in range(x_rest):
-                loaded_img[x + (width - x_rest), y + (height - y_rest)] = tuple(pixel_buffer.read(channels_count))
+            Console.progress_bar(locale.join_pic, y_chunk, y_chunks_count + 1)
 
 
 def split_image(img: Image):
@@ -70,34 +59,25 @@ def add_pixel(pixel: tuple):
 
     x_chunks_count = width // chunk_size
     y_chunks_count = height // chunk_size
-    x_rest = width % chunk_size
-    y_rest = height % chunk_size
 
     pixel_index = 0
 
-    for y_chunk in range(y_chunks_count):
-        for x_chunk in range(x_chunks_count):
+    for y_chunk in range(y_chunks_count + 1):
+        for x_chunk in range(x_chunks_count + 1):
             for y in range(chunk_size):
-                for x in range(chunk_size):
-                    add_pixel(loaded_clone[x + (x_chunk * chunk_size), y + (y_chunk * chunk_size)])
-                    pixel_index += 1
+                pixel_y = (y_chunk * chunk_size) + y
+                if pixel_y >= height:
+                    break
 
-        for y in range(chunk_size):
-            for x in range(x_rest):
-                add_pixel(loaded_clone[x + (width - x_rest), y + (y_chunk * chunk_size)])
-                pixel_index += 1
-        Console.progress_bar(locale.split_pic, y_chunk, y_chunks_count)
+                for x in range(chunk_size):
+                    pixel_x = (x_chunk * chunk_size) + x
+                    if pixel_x >= width:
+                        break
 
-    for x_chunk in range(width // chunk_size):
-        for y in range(y_rest):
-            for x in range(chunk_size):
-                add_pixel(loaded_clone[x + (x_chunk * chunk_size), y + (height - y_rest)])
-                pixel_index += 1
+                    add_pixel(loaded_clone[pixel_x, pixel_y])
+                    pixel_index += 1
 
-    for y in range(y_rest):
-        for x in range(x_rest):
-            add_pixel(loaded_clone[x + (width - x_rest), y + (height - y_rest)])
-            pixel_index += 1
+        Console.progress_bar(locale.split_pic, y_chunk, y_chunks_count + 1)
 
 
 def get_pixel_size(_type):
@@ -123,7 +103,7 @@ def pixel_type2str(_type):
     raise Exception(locale.unk_type % _type)
 
 
-def bytes2rgba(data: Reader, _type, img):
+def load_texture(data: Reader, _type, img):
     read_pixel = None
     channels_count = 4
     if _type in (0, 1):
@@ -175,7 +155,7 @@ def read_pixel():
     print()
 
 
-def rgba2bytes(sc, img, _type):
+def save_texture(sc, img, _type):
     write_pixel = None
     if _type in (0, 1):
         def write_pixel(pixel):

system/lib/objects/shape.py

@@ -97,13 +97,15 @@ def load(self, swf, tag: int):
         self.shape_points = [_class() for _class in [Point] * self.points_count]
         self.sheet_points = [_class() for _class in [Point] * self.points_count]
 
+        multiplier = 0.5 if swf.use_lowres_texture else 1
+
         for z in range(self.points_count):
-            self.shape_points[z].x = swf.reader.read_int32() / 20
-            self.shape_points[z].y = swf.reader.read_int32() / 20
+            self.shape_points[z].x = swf.reader.read_int32() / 20 * multiplier
+            self.shape_points[z].y = swf.reader.read_int32() / 20 * multiplier
         for z in range(self.points_count):
-            w, h = [swf.reader.read_uint16() * swf.textures[self.texture_id].width / 0xffff,
-                    swf.reader.read_uint16() * swf.textures[self.texture_id].height / 0xffff]
-            x, y = [ceil(i) for i in (w, h)]
+            w, h = [swf.reader.read_uint16() * swf.textures[self.texture_id].width / 0xffff * multiplier,
+                    swf.reader.read_uint16() * swf.textures[self.texture_id].height / 0xffff * multiplier]
+            x, y = map(ceil, (w, h))
             if int(w) == x:
                 x += 1
             if int(h) == y:

system/lib/objects/texture.py

@@ -2,7 +2,7 @@
 
 from PIL import Image
 
-from system.lib.images import pixel_type2str, bytes2rgba, join_image, load_image_from_buffer
+from system.lib.images import pixel_type2str, load_texture, join_image, load_image_from_buffer
 
 
 class SWFTexture:
@@ -21,7 +21,7 @@ def load(self, swf, tag: int, has_texture: bool):
         if has_texture:
             img = Image.new(pixel_type2str(self.pixel_type), (self.width, self.height))
 
-            bytes2rgba(swf.reader, self.pixel_type, img)
+            load_texture(swf.reader, self.pixel_type, img)
 
             if tag in (27, 28):
                 join_image(img)