#!/usr/bin/env python3
"""
gen_tile_placeholders.py — ЗАГЛУШКИ для 32 типов тайлов (не графика
оригинала!) — простая процедурная геометрия (кирпичная кладка линиями,
плоская поверхность и т.п.), чтобы визуально читалось "это стена"/
"это пол", пока не готовы настоящие ассеты (см. room.h/room.c:
tile_atlas[TYPE], вариант 0 — "index"-картинка на тип).

Выход: applications/PoP/poc/res/tiles/{TYPE:X}-0.png — 32 файла,
32x64 (ROOM_TILE_W x room_row_h), RGBA.

Для твёрдых типов (Фаза 1: Floor/Wall/Pillar/PillarBot/PillarTop/
BalconyL/R) — функциональная заглушка (см. draw_wall_like/draw_floor
ниже); Lattice-типы (0x19-0x1D) — узкая проходимая колонна той же
кладки (draw_lattice_like, см. reference-скриншот оригинала); для
остальных (декоративные/интерактивные, вне объёма Фазы 1) — просто
цвет + подпись, этого достаточно для отладки конвейера.  Empty (0x00)
— полностью прозрачно (ничего не рисуется).

По мере готовности настоящих ассетов — рядом кладутся 0-1.png,
0-2.png и т.д. (следующие варианты той же ленты), см. room.h.
"""
import colorsys
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont

W, H = 32, 64

NAMES = [
    "Empty", "Floor", "Spikes", "Pillar", "Gate", "StuckBtn", "DropBtn",
    "Tapestry", "PillarBot", "PillarTop", "Potion", "Loose", "TapestryTop",
    "Mirror", "Debris", "RaiseBtn", "ExitL", "ExitR", "Chopper", "Torch",
    "Wall", "Skeleton", "Sword", "BalconyL", "BalconyR", "LatticePillar",
    "LatticeSupport", "LatticeSmall", "LatticeL", "LatticeR", "TorchDebris",
    "Null",
]
assert len(NAMES) == 32

WALL_LIKE = {0x03, 0x08, 0x09, 0x14, 0x17, 0x18}   # Pillar/PillarBot/Top/Wall/BalconyL/R
FLOOR_LIKE = {0x01}                                 # Floor
# Lattice — узкие декоративные каменные колонны (см. reference-скриншот
# оригинала 2026-07-16): Кид физически проходит МИМО них (не полноценная
# стена на всю ширину тайла) — колонна той же STONE/MORTAR кладки, но
# ýже тайла, с прозрачными полями по бокам.  (col_w, align):
# align: "center"/"left"/"right".
LATTICE_LIKE = {
    0x19: (14, "center"),   # LatticePillar
    0x1A: (18, "center"),   # LatticeSupport — потолще
    0x1B: (10, "center"),   # LatticeSmall — потоньше
    0x1C: (14, "left"),     # LatticeLeft
    0x1D: (14, "right"),    # LatticeRight
}
# Плоский однотонный цвет БЕЗ текста (не через антиалиасинг шрифта) —
# держит "своих" цветов в палитре по 1 на тип, иначе объединённая
# палитра (--seed-pal) быстро упирается в лимит 0xFF (см.
# pop_tile_atlas_palette_merge в памяти).
FLAT_LIKE = {0x13: (200, 90, 30, 255),    # Torch — тёплый оранжевый
             0x0E: (110, 90, 70, 255),    # Debris — серо-бурый
             0x0B: (140, 120, 60, 255)}   # Loose — тускло-жёлтый (плита)

STONE = (150, 150, 158, 255)
MORTAR = (90, 90, 98, 255)
GROUND = (120, 100, 80, 255)
GROUND_TOP = (170, 150, 120, 255)

out_dir = Path(__file__).resolve().parent.parent / "res" / "tiles"
out_dir.mkdir(parents=True, exist_ok=True)

try:
    font = ImageFont.load_default()
except Exception:
    font = None


def draw_wall_like(im):
    """Кирпичная кладка — просто ряды прямоугольников со смещением
    в шахматном порядке и линиями раствора между ними (обобщённый
    геометрический приём, не стиль конкретной игры)."""
    draw = ImageDraw.Draw(im)
    draw.rectangle([0, 0, W - 1, H - 1], fill=STONE)
    brick_h = 12
    brick_w = 16
    row = 0
    y = 0
    while y < H:
        offset = (brick_w // 2) if (row % 2) else 0
        x = -brick_w + offset
        while x < W:
            draw.rectangle([x, y, x + brick_w - 2, y + brick_h - 2],
                           outline=MORTAR, width=1)
            x += brick_w
        y += brick_h
        row += 1


def draw_lattice_like(im, col_w, align):
    """Узкая колонна кирпичной кладки шириной col_w<W, остальное — прозрачно
    (проходимо мимо).  align выбирает, к какому краю тайла её прижать.
    Колонна ýже одного "кирпича" — рисуем стопкой блоков (горизонтальные
    линии раствора), без горизонтального смещения рядов, как у широкой
    стены (там оно не помещается)."""
    if align == "left":
        x0 = 0
    elif align == "right":
        x0 = W - col_w
    else:
        x0 = (W - col_w) // 2
    draw = ImageDraw.Draw(im)
    draw.rectangle([x0, 0, x0 + col_w - 1, H - 1], fill=STONE)
    brick_h = 12
    y = brick_h
    while y < H:
        draw.line([(x0, y), (x0 + col_w - 1, y)], fill=MORTAR, width=1)
        y += brick_h
    draw.rectangle([x0, 0, x0 + col_w - 1, H - 1], outline=MORTAR, width=1)


def draw_floor_like(im):
    """Пол — плоская поверхность: верхние ~12px твёрдые (то, на чём
    стоишь), светлая полоса-хайлайт сверху, ниже — темнее/пусто."""
    draw = ImageDraw.Draw(im)
    surf_h = 14
    draw.rectangle([0, 0, W - 1, surf_h - 1], fill=GROUND)
    draw.line([(0, 0), (W - 1, 0)], fill=GROUND_TOP, width=2)
    draw.rectangle([0, surf_h, W - 1, H - 1], fill=(GROUND[0]//2, GROUND[1]//2, GROUND[2]//2, 255))


for t in range(32):
    if t == 0:
        im = Image.new("RGBA", (W, H), (0, 0, 0, 0))   # Empty — прозрачно
    elif t in WALL_LIKE:
        im = Image.new("RGBA", (W, H), (0, 0, 0, 0))
        draw_wall_like(im)
    elif t in FLOOR_LIKE:
        im = Image.new("RGBA", (W, H), (0, 0, 0, 0))
        draw_floor_like(im)
    elif t in FLAT_LIKE:
        im = Image.new("RGBA", (W, H), FLAT_LIKE[t])
    elif t in LATTICE_LIKE:
        im = Image.new("RGBA", (W, H), (0, 0, 0, 0))
        col_w, align = LATTICE_LIKE[t]
        draw_lattice_like(im, col_w, align)
    else:
        hue = (t - 1) / 31.0
        r, g, b = (int(c * 255) for c in colorsys.hsv_to_rgb(hue, 0.55, 0.85))
        im = Image.new("RGBA", (W, H), (r, g, b, 255))
        draw = ImageDraw.Draw(im)
        draw.rectangle([0, 0, W - 1, H - 1], outline=(0, 0, 0, 255))
        draw.text((2, 2), "%X" % t, fill=(0, 0, 0, 255), font=font)
        draw.text((2, H - 12), NAMES[t][:6], fill=(0, 0, 0, 255), font=font)
    im.save(out_dir / ("%X-0.png" % t))

print(f"gen_tile_placeholders: 32 файла -> {out_dir}")