pollo/tools/tmx_to_yaml.py

#!/usr/bin/env python3
"""
Script para migrar tilemaps de archivos TMX (Tiled) a archivos YAML.

Uso:
    python tools/tmx_to_yaml.py

Busca todos los archivos .tmx en data/room/ y actualiza el tilemap
en el archivo .yaml correspondiente.
"""

import xml.etree.ElementTree as ET
from pathlib import Path
import re


def parse_layer_csv(data_element, width: int, height: int, offset: int) -> list[list[int]]:
    """
    Parsea los datos CSV de una capa y convierte los indices.

    Args:
        data_element: Elemento XML con los datos CSV
        width: Ancho del mapa en tiles
        height: Alto del mapa en tiles
        offset: Valor a restar de los indices (excepto 0 que pasa a -1)

    Returns:
        Lista de filas, cada fila es una lista de indices
    """
    encoding = data_element.attrib.get('encoding', '')
    if encoding != 'csv':
        raise ValueError(f"Encoding no soportado: {encoding}. Solo se soporta CSV.")

    csv_text = data_element.text.strip()
    all_values = []
    for val in csv_text.replace('\n', ',').split(','):
        val = val.strip()
        if val:
            all_values.append(int(val))

    # Convertir indices: 0 -> -1, N -> N - offset
    result = []
    for y in range(height):
        row = []
        for x in range(width):
            idx = y * width + x
            tmx_val = all_values[idx]
            if tmx_val == 0:
                yaml_val = -1
            else:
                yaml_val = tmx_val - offset
            row.append(yaml_val)
        result.append(row)

    return result


def parse_tmx(tmx_path: Path) -> tuple[list[list[int]], list[list[int]] | None, int, int]:
    """
    Parsea un archivo TMX y extrae el tilemap y collisionmap.

    Returns:
        tilemap: Lista de filas para el tilemap (layer id=1)
        collisionmap: Lista de filas para el collisionmap (layer id=2), o None si no existe
        width: Ancho del mapa en tiles
        height: Alto del mapa en tiles
    """
    tree = ET.parse(tmx_path)
    root = tree.getroot()

    width = int(root.attrib['width'])
    height = int(root.attrib['height'])

    # Obtener firstgid del primer tileset (para tilemap)
    tileset = root.find('tileset')
    firstgid = int(tileset.attrib['firstgid']) if tileset is not None else 1

    # Buscar las capas por id
    layers = root.findall('layer')
    layer1 = None
    layer2 = None
    for layer in layers:
        layer_id = layer.attrib.get('id')
        if layer_id == '1':
            layer1 = layer
        elif layer_id == '2':
            layer2 = layer

    # Parsear layer 1 (tilemap) - obligatoria
    if layer1 is None:
        raise ValueError(f"No se encontro layer id=1 en {tmx_path}")

    data1 = layer1.find('data')
    if data1 is None:
        raise ValueError(f"No se encontraron datos en layer 1 de {tmx_path}")

    tilemap = parse_layer_csv(data1, width, height, firstgid)

    # Parsear layer 2 (collisionmap) - opcional
    collisionmap = None
    if layer2 is not None:
        data2 = layer2.find('data')
        if data2 is not None:
            # Para collisionmap: 0 -> -1, N -> N - 576
            collisionmap = parse_layer_csv(data2, width, height, 576)

    return tilemap, collisionmap, width, height


def format_tilemap_yaml(tilemap: list[list[int]], width: int, height: int) -> str:
    """
    Formatea el tilemap como YAML.
    """
    lines = []
    lines.append(f"# Tilemap: {height} filas x {width} columnas ({width*8}x{height*8} pixeles @ 8px/tile)")
    lines.append("# Indices de tiles (-1 = vacio)")
    lines.append("tilemap:")

    for row in tilemap:
        row_str = ", ".join(str(v) for v in row)
        lines.append(f"  - [{row_str}]")

    return "\n".join(lines)


def format_collisionmap_yaml(collisionmap: list[list[int]], width: int, height: int) -> str:
    """
    Formatea el collisionmap como YAML.
    """
    lines = []
    lines.append(f"# Collisionmap: {height} filas x {width} columnas")
    lines.append("# Indices de colision (-1 = vacio, 1 = solido, 2 = plataforma)")
    lines.append("collisionmap:")

    for row in collisionmap:
        row_str = ", ".join(str(v) for v in row)
        lines.append(f"  - [{row_str}]")

    return "\n".join(lines)


def update_yaml_tilemap(yaml_path: Path, tilemap: list[list[int]], collisionmap: list[list[int]] | None, width: int, height: int) -> bool:
    """
    Actualiza la seccion tilemap y collisionmap de un archivo YAML.

    Returns:
        True si se actualizo correctamente, False si hubo error
    """
    if not yaml_path.exists():
        print(f"  ADVERTENCIA: {yaml_path} no existe, saltando...")
        return False

    content = yaml_path.read_text(encoding='utf-8')

    # Buscar donde empieza la seccion tilemap (incluyendo comentarios previos)
    # Capturar cualquier bloque de comentarios seguidos justo antes de tilemap:
    tilemap_pattern = re.compile(
        r'(#[^\n]*\n)*'       # Cualquier comentario antes de tilemap
        r'tilemap:\s*\n'      # Inicio de tilemap
        r'(  - \[.*\]\n?)+'   # Filas del tilemap
    )

    match = tilemap_pattern.search(content)
    if not match:
        print(f"  ERROR: No se encontro seccion tilemap en {yaml_path}")
        return False

    # Verificar que capturamos comentarios relacionados con tilemap
    # Si el match incluye comentarios no relacionados, ajustar el inicio
    matched_text = match.group(0)
    lines = matched_text.split('\n')

    # Buscar donde empiezan los comentarios de tilemap (los que queremos reemplazar)
    start_idx = 0
    for i, line in enumerate(lines):
        if line.startswith('#') and ('tilemap' in line.lower() or 'indice' in line.lower() or 'tile' in line.lower()):
            start_idx = i
            break
        elif line.startswith('tilemap:'):
            start_idx = i
            break

    # Ajustar el inicio del match si hay comentarios que no queremos eliminar
    if start_idx > 0:
        skip_chars = sum(len(lines[i]) + 1 for i in range(start_idx))
        actual_start = match.start() + skip_chars
    else:
        actual_start = match.start()

    # Generar nuevo tilemap
    new_tilemap = format_tilemap_yaml(tilemap, width, height)

    # Reemplazar desde actual_start (que puede ser ajustado si hay comentarios no relacionados)
    new_content = content[:actual_start] + new_tilemap + "\n" + content[match.end():]

    # Procesar collisionmap si existe
    if collisionmap is not None:
        new_collisionmap = format_collisionmap_yaml(collisionmap, width, height)

        # Buscar si ya existe seccion collisionmap
        collisionmap_pattern = re.compile(
            r'(#[^\n]*\n)*'           # Cualquier comentario antes de collisionmap
            r'collisionmap:\s*\n'     # Inicio de collisionmap
            r'(  - \[.*\]\n?)+'       # Filas del collisionmap
        )

        collision_match = collisionmap_pattern.search(new_content)
        if collision_match:
            # Reemplazar collisionmap existente
            collision_matched_text = collision_match.group(0)
            collision_lines = collision_matched_text.split('\n')

            # Buscar donde empiezan los comentarios de collisionmap
            collision_start_idx = 0
            for i, line in enumerate(collision_lines):
                if line.startswith('#') and ('collision' in line.lower()):
                    collision_start_idx = i
                    break
                elif line.startswith('collisionmap:'):
                    collision_start_idx = i
                    break

            if collision_start_idx > 0:
                skip_chars = sum(len(collision_lines[i]) + 1 for i in range(collision_start_idx))
                collision_actual_start = collision_match.start() + skip_chars
            else:
                collision_actual_start = collision_match.start()

            new_content = new_content[:collision_actual_start] + new_collisionmap + "\n" + new_content[collision_match.end():]
        else:
            # Insertar collisionmap despues del tilemap
            # Buscar el fin del tilemap recien insertado
            tilemap_end_pattern = re.compile(r'tilemap:\s*\n(  - \[.*\]\n?)+')
            tilemap_end_match = tilemap_end_pattern.search(new_content)
            if tilemap_end_match:
                insert_pos = tilemap_end_match.end()
                new_content = new_content[:insert_pos] + "\n" + new_collisionmap + "\n" + new_content[insert_pos:]

    yaml_path.write_text(new_content, encoding='utf-8')
    return True


def main():
    # Directorio de habitaciones
    script_dir = Path(__file__).parent
    room_dir = script_dir.parent / "data" / "room"

    if not room_dir.exists():
        print(f"ERROR: No se encontro directorio {room_dir}")
        return 1

    # Buscar archivos TMX
    tmx_files = sorted(room_dir.glob("*.tmx"))

    if not tmx_files:
        print("No se encontraron archivos .tmx en data/room/")
        return 0

    print(f"Encontrados {len(tmx_files)} archivos TMX")
    print()

    success_count = 0
    error_count = 0

    for tmx_path in tmx_files:
        yaml_path = tmx_path.with_suffix('.yaml')
        print(f"Procesando: {tmx_path.name} -> {yaml_path.name}")

        try:
            tilemap, collisionmap, width, height = parse_tmx(tmx_path)
            print(f"  TMX: {width}x{height} tiles")
            if collisionmap is not None:
                print(f"  Collisionmap detectado")

            if update_yaml_tilemap(yaml_path, tilemap, collisionmap, width, height):
                print(f"  OK: Tilemap actualizado")
                if collisionmap is not None:
                    print(f"  OK: Collisionmap actualizado")
                success_count += 1
            else:
                error_count += 1

        except Exception as e:
            print(f"  ERROR: {e}")
            error_count += 1

    print()
    print(f"Completado: {success_count} exitosos, {error_count} errores")
    return 0 if error_count == 0 else 1


if __name__ == "__main__":
    exit(main())