Update app.py

app.py

@@ -2,19 +2,21 @@ import gradio as gr
 import bz2
 import bson
 import struct
-from typing import List, Dict, Any
+from typing import List, Dict, Tuple
 
 # ---------- низкоуровневые хелперы ----------
 def _u8(buf, off) -> int:
     return buf[off]
 def _u16(buf, off) -> int:
     return struct.unpack_from('<H', buf, off)[0]
+def _u32(buf, off) -> int:
+    return struct.unpack_from('<I', buf, off)[0]
 def _i8(buf, off) -> int:
     return struct.unpack_from('<b', buf, off)[0]
 
 # ---------- чтение partsPos ----------
 def read_parts_pos(partsPos: bytes, bx: int, by: int) -> List[int]:
-    """Возвращает сколько частиц в каждой клетке (длина = bx*by)"""
+    """Возвращает список длиной bx*by – сколько частиц в каждой клетке"""
     if len(partsPos) != bx * by * 3:
         raise ValueError(f'partsPos length mismatch: expected {bx*by*3}, got {len(partsPos)}')
     cnt_map = []
@@ -24,7 +26,7 @@ def read_parts_pos(partsPos: bytes, bx: int, by: int) -> List[int]:
         cnt_map.append(cnt)
     return cnt_map
 
-# ---------- класс Particle ----------
+# ---------- чтение parts ----------
 class Particle:
     __slots__ = ('type', 'x', 'y', 'temp', 'life', 'tmp', 'ctype',
                  'dcolour', 'vx', 'vy', 'tmp2', 'tmp3', 'tmp4')
@@ -44,22 +46,17 @@ class Particle:
         self.tmp3: int = 0
         self.tmp4: int = 0
     
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Dict:
         return {field: getattr(self, field) for field in self.__slots__}
     
     def __repr__(self):
         return f'Particle(type={self.type} @{self.x:.1f},{self.y:.1f})'
 
-# ---------- чтение parts ----------
 def read_parts(partsData: bytes, partsPosCounts: List[int],
-               bx: int, by: int, cell_size: int = 4) -> List[Dict[str, Any]]:
-    """
-    partsData – байты из BSON['parts']
-    partsPosCounts – результат read_parts_pos
-    Возвращает список частиц как dict
-    """
+               bx: int, by: int, cell_size: int = 4) -> List[Particle]:
+    """Парсит массив частиц из бинарных данных"""
     px_per_cell = cell_size
-    particles: List[Dict[str, Any]] = []
+    parts: List[Particle] = []
     off = 0
     data_len = len(partsData)
 
@@ -67,19 +64,17 @@ def read_parts(partsData: bytes, partsPosCounts: List[int],
         for x in range(bx):
             cnt = partsPosCounts[y * bx + x]
             base_x, base_y = x * px_per_cell, y * px_per_cell
-            
             for _ in range(cnt):
                 if off >= data_len - 3:
                     raise ValueError('truncated partsData')
                 
-                # 1. type (1 байт + возможно второй)
+                # type (1 байт + возможно второй)
                 ty = _u8(partsData, off)
                 off += 1
                 
-                # 2. field-descriptor 2 байта
+                # field-descriptor 2 байта
                 fd = _u16(partsData, off)
                 off += 2
-                
                 has_fd3 = bool(fd & 0x8000)
                 if has_fd3:
                     if off >= data_len:
@@ -178,84 +173,95 @@ def read_parts(partsData: bytes, partsPosCounts: List[int],
                         p.tmp4 |= _u16(partsData, off + 2) << 16
                         off += 4
 
-                particles.append(p.to_dict())
-    
-    return particles
+                parts.append(p)
+    return parts
+
+def get_block_size(bson_dict: Dict) -> Tuple[int, int]:
+    """Извлекает размеры сейва в блоках из BSON-словаря"""
+    bx = bson_dict.get('blockSizeX', 0)
+    by = bson_dict.get('blockSizeY', 0)
+    if not bx or not by:
+        block_size = bson_dict.get('blockSize', [0, 0])
+        if isinstance(block_size, list) and len(block_size) == 2:
+            bx, by = block_size
+        else:
+            raise ValueError("Не удалось извлечь размеры сейва")
+    return bx, by
 
 # ---------- основная функция Gradio ----------
 def analyze_cps(file):
     if file is None:
-        return "", "", ""
-    
+        return "", "", "", ""
+
     try:
         with open(file.name, "rb") as f:
             raw_data = f.read()
-        
+
+        # HEX дамп оригинала
         hex_orig = ' '.join(f'{b:02x}' for b in raw_data[:256])
         hex_original = f"Оригинал (первые 256 байт):\n{hex_orig}"
-        
+
+        # Проверка сигнатуры
         if raw_data[:4] != b'OPS1':
-            return hex_original, "[Ошибка] Неверная сигнатура файла.", ""
-        
+            return hex_original, "[Ошибка] Неверная сигнатура файла.", "", ""
+
+        # Распаковка bzip2
         compressed = raw_data[12:]
         try:
             decompressed = bz2.decompress(compressed)
         except Exception as e:
-            return hex_original, f"[Ошибка bzip2]: {e}", ""
-        
+            return hex_original, f"[Ошибка bzip2]: {e}", "", ""
+
+        # HEX дамп распакованных данных
         hex_decomp = ' '.join(f'{b:02x}' for b in decompressed[:512])
         hex_decomp_view = f"Распакованные данные (первые 512 байт):\n{hex_decomp}"
-        
+
+        # Парсинг BSON
         try:
             doc = bson.decode(decompressed)
         except Exception as e:
-            return hex_original, hex_decomp_view, f"[Ошибка BSON]: {e}"
-        
-        # Парсим parts
-        if 'parts' in doc and 'partsPos' in doc and 'blockSize' in doc:
+            return hex_original, hex_decomp_view, f"[Ошибка BSON]: {e}", ""
+
+        # Парсинг parts и partsPos
+        if 'parts' in doc and 'partsPos' in doc:
             try:
-                # Получаем размеры блока
-                block_size = doc['blockSize']
-                if isinstance(block_size, dict):
-                    bx, by = block_size.get('x', 0), block_size.get('y', 0)
-                elif isinstance(block_size, (list, tuple)):
-                    bx, by = block_size[0], block_size[1]
-                else:
-                    bx = by = int(block_size)
-                
-                if bx <= 0 or by <= 0:
-                    raise ValueError(f"Invalid blockSize: {block_size}")
-                
-                # Читаем partsPos и parts
+                bx, by = get_block_size(doc)
                 parts_pos_raw = bytes(doc['partsPos'])
                 parts_raw = bytes(doc['parts'])
                 
+                # Читаем карту количества частиц
                 counts = read_parts_pos(parts_pos_raw, bx, by)
-                parsed_parts = read_parts(parts_raw, counts, bx, by)
+                total_particles = sum(counts)
                 
-                # Заменяем бинарные данные на распарсенные
-                doc['parts'] = f"[{len(parsed_parts)} particles parsed]"
-                doc['partsPos'] = f"[{len(counts)} cells]"
-                doc['_particles'] = parsed_parts  # Сохраняем отдельно
+                # Читаем сами частицы
+                particles = read_parts(parts_raw, counts, bx, by)
+                
+                # Заменяем бинарные данные на список словарей
+                doc['parts'] = [p.to_dict() for p in particles]
+                doc['partsPos'] = f"Карта количества частиц ({bx}x{by} = {len(counts)} клеток)"
+                doc['__info'] = f"Всего частиц: {total_particles}"
                 
             except Exception as e:
-                doc['parts'] = f"[Ошибка парсинга]: {e}"
-                doc['partsPos'] = f"[Ошибка парсинга]: {e}"
-        
+                doc['parts'] = f"[Ошибка парсинга parts]: {e}"
+                doc['partsPos'] = f"[Ошибка парсинга partsPos]: {e}"
+
         return hex_original, hex_decomp_view, str(doc)
-    
+
     except Exception as e:
-        return f"[Ошибка]: {e}", "", ""
+        return f"[Ошибка]: {e}", "", "", ""
 
-# ---------- Gradio интерфейс ----------
+# ---------- Gradio UI ----------
 with gr.Blocks() as demo:
-    gr.Markdown("## Распаковка .cps (The Powder Toy) с полным парсингом частиц")
+    gr.Markdown("## 🔬 Распаковка и анализ .cps (The Powder Toy Save)")
+    gr.Markdown("Загрузите файл `.cps`, чтобы увидеть полную структуру данных, включая частицы.")
     
     file_input = gr.File(label="Загрузите .cps файл", file_types=[".cps"])
     
-    hex_orig_out = gr.Textbox(label="HEX оригинала", lines=5)
-    hex_decomp_out = gr.Textbox(label="HEX распакованных данных", lines=10)
-    bson_parsed = gr.Textbox(label="Распарсенный BSON", lines=30)
+    with gr.Row():
+        hex_orig_out = gr.Textbox(label="HEX оригинального файла", lines=5)
+        hex_decomp_out = gr.Textbox(label="HEX распакованных данных", lines=10)
+    
+    bson_parsed = gr.Textbox(label="Распарсенный BSON (с частицами)", lines=30)
     
     file_input.change(
         fn=analyze_cps,