render.py

Part of Bloom.

"""Bloom rendering: a plain helper class (not a Node) that lays out and draws
the hex board via immediate-mode Draw2D. Reads board + per-cell effect state;
owns no game logic and no input.

The "Petalfall" look: each cell is a small domed petal (concentric hexes shade
rim -> mid -> a glowing core), grounded by a soft drop shadow. Owned cores sit
just above 1.0 in their dominant channel so the WorldEnvironment bloom catches
only them, giving the resting board a calm permanent glow. Captures briefly
flash the cell to its HI colour (also >1.0) and leave an additive afterglow.
"""

import math

from board import Board, Owner
from hex_grid import SQRT3, Hex, hex_corners, hex_to_pixel, pixel_to_hex

from simvx.core import Vec2

# --- palette (RGBA floats; Canadian spelling) --------------------------------
# Only owned CORES and the flip HI peaks cross 1.0, so only they bloom. Every
# matte fill, grid line, outline and HUD element stays <= 1.0 and never glows.
EMPTY = (0.205, 0.215, 0.255, 1.0)  # soil
GRID_LINE = (0.34, 0.37, 0.46, 1.0)
WARM = (0.85, 0.52, 0.20, 1.0)  # marigold, matte base/mid
WARM_CORE = (1.12, 0.80, 0.45, 1.0)  # resting glow core (>1.0 R)
WARM_HI = (1.35, 0.92, 0.55, 1.0)  # flip flash peak / afterglow tint
COOL = (0.28, 0.55, 0.85, 1.0)  # cornflower, matte base/mid
COOL_CORE = (0.55, 0.80, 1.12, 1.0)  # resting glow core (>1.0 B)
COOL_HI = (0.62, 0.92, 1.35, 1.0)
LAST_OUTLINE = (1.0, 1.0, 1.0, 0.85)
SHADOW = (0.0, 0.0, 0.0, 0.22)

_HEX_GAP = 0.90  # fraction of cell size actually drawn (leaves grid gutters)
_FIT_MARGIN = 0.94
_MID_FRAC = 0.80  # mid dome layer, fraction of the base
_CORE_FRAC = 0.50  # bright core layer


def screen_wh(tree) -> tuple[float, float]:
    """Viewport size as (w, h). ``SceneTree.screen_size`` is already normalized."""
    return tree.screen_size


def owner_colour(o: Owner) -> tuple[float, float, float, float]:
    if o is Owner.WARM:
        return WARM
    if o is Owner.COOL:
        return COOL
    return EMPTY


def core_colour(o: Owner) -> tuple[float, float, float, float]:
    return WARM_CORE if o is Owner.WARM else COOL_CORE


def highlight_colour(o: Owner) -> tuple[float, float, float, float]:
    return WARM_HI if o is Owner.WARM else COOL_HI


def lerp_colour(a, b, t: float):
    t = 0.0 if t < 0.0 else 1.0 if t > 1.0 else t
    return tuple(a[i] + (b[i] - a[i]) * t for i in range(4))


def scale_rgb(c, f: float, alpha: float | None = None):
    a = c[3] if alpha is None else alpha
    return (min(c[0] * f, 2.0), min(c[1] * f, 2.0), min(c[2] * f, 2.0), a)


def draw_ring(renderer, cx: float, cy: float, r_out: float, r_in: float, col) -> None:
    """Additive expanding hex annulus (pollen ripple). Built from 6 filled quads
    because polygon can't fill a polygon with a hole, and only FILLED
    primitives honour blend on both backends."""
    out = hex_corners(Vec2(cx, cy), r_out)
    inn = hex_corners(Vec2(cx, cy), max(0.0, r_in))
    for i in range(6):
        j = (i + 1) % 6
        quad = [(out[i].x, out[i].y), (out[j].x, out[j].y), (inn[j].x, inn[j].y), (inn[i].x, inn[i].y)]
        renderer.polygon(quad, fill=col, blend="add")


def draw_disc(renderer, cx: float, cy: float, r: float, col, segments: int = 14) -> None:
    """Soft additive disc (background pollen mote). circle has no blend param,
    so approximate with an additive filled polygon."""
    pts = [
        (cx + r * math.cos(math.tau * i / segments), cy + r * math.sin(math.tau * i / segments))
        for i in range(segments)
    ]
    renderer.polygon(pts, fill=col, blend="add")


def draw_petal(renderer, x: float, y: float, s: float, ang: float, col) -> None:
    """Additive 4-point petal/diamond, rotated by ``ang``."""
    c, sn = math.cos(ang), math.sin(ang)
    pts = [(0.0, -s * 1.4), (s * 0.7, 0.0), (0.0, s * 1.4), (-s * 0.7, 0.0)]
    renderer.polygon([(x + px * c - py * sn, y + px * sn + py * c) for (px, py) in pts], fill=col, blend="add")


def draw_flower(renderer, cx: float, cy: float, petal_len: float, col) -> None:
    """Soft additive 6-petal flower with a glowing centre (decorative backdrop)."""
    for k in range(6):
        a = math.tau * k / 6.0
        px = cx + math.cos(a) * petal_len * 0.6
        py = cy + math.sin(a) * petal_len * 0.6
        draw_petal(renderer, px, py, petal_len * 0.5, a - math.pi / 2, col)


class CellFx:
    """Mutable per-cell animation state the engine ``tween`` writes into."""

    __slots__ = ("scale", "flash", "afterglow", "from_col", "to_col")

    def __init__(self, colour):
        self.scale = 1.0  # 1.0 resting; pops above 1 then settles
        self.flash = 1.0  # 0..1 blend from_col -> to_col
        self.afterglow = 0.0  # 0..1 additive capture glow that lingers then fades
        self.from_col = colour
        self.to_col = colour

    @property
    def colour(self):
        return lerp_colour(self.from_col, self.to_col, self.flash)


class HexBoardView:
    """Fits, hit-tests and draws a Bloom board inside a rectangular play area."""

    def __init__(self):
        self.origin = Vec2(0, 0)
        self.size = 28.0
        self.fx: dict[Hex, CellFx] = {}

    # --- layout -------------------------------------------------------------
    def layout(self, board: Board, area_x: float, area_y: float, area_w: float, area_h: float) -> None:
        """Compute origin/size so the whole flower fits the play area, centred."""
        xs, ys = [], []
        for h in board.cells:
            xs.append(SQRT3 * h.q + SQRT3 / 2 * h.r)
            ys.append(1.5 * h.r)
        span_x = (max(xs) - min(xs)) + SQRT3  # + one cell width (pointy-top)
        span_y = (max(ys) - min(ys)) + 2.0  # + one cell height
        self.size = _FIT_MARGIN * min(area_w / span_x, area_h / span_y)
        mid_x = (max(xs) + min(xs)) / 2 * self.size
        mid_y = (max(ys) + min(ys)) / 2 * self.size
        self.origin = Vec2(area_x + area_w / 2 - mid_x, area_y + area_h / 2 - mid_y)

    def ensure_fx(self, board: Board) -> None:
        """Create any missing effect holders, matched to current ownership."""
        for h, o in board.cells.items():
            if h not in self.fx:
                self.fx[h] = CellFx(owner_colour(o))

    def sync_static(self, board: Board) -> None:
        """Snap every cell's colour to the board with no animation."""
        self.fx.clear()
        for h, o in board.cells.items():
            self.fx[h] = CellFx(owner_colour(o))

    # --- hit-test -----------------------------------------------------------
    def pixel_to_hex(self, px: float, py: float) -> Hex:
        return pixel_to_hex(px, py, self.origin, self.size)

    def centre_of(self, h: Hex) -> Vec2:
        return hex_to_pixel(h, self.origin, self.size)

    def _verts(self, centre: Vec2, frac: float) -> list[tuple[float, float]]:
        return [(c.x, c.y) for c in hex_corners(centre, self.size * frac)]

    # --- draw ---------------------------------------------------------------
    def draw(self, renderer, board: Board) -> None:
        self.ensure_fx(board)
        sz = self.size
        sx, sy = sz * 0.05, sz * 0.07
        for h, owner in board.cells.items():
            fx = self.fx[h]
            centre = hex_to_pixel(h, self.origin, sz)
            base_frac = _HEX_GAP * fx.scale
            base = self._verts(centre, base_frac)
            # (0) drop shadow grounds the cell on the soil
            shadow = [(x + sx, y + sy) for (x, y) in base]
            renderer.polygon(shadow, fill=SHADOW)
            if owner is Owner.EMPTY:
                renderer.polygon(base, fill=fx.colour)
                renderer.polygon(base, stroke=GRID_LINE)
                continue
            # owned: domed petal = rim -> mid -> glowing core
            col = fx.colour  # animates to HI during a flip flash (blooms), then settles
            renderer.polygon(base, fill=scale_rgb(col, 0.80))
            renderer.polygon(self._verts(centre, base_frac * _MID_FRAC), fill=col)
            renderer.polygon(self._verts(centre, base_frac * _CORE_FRAC), fill=core_colour(owner))
            # rim light all around (subtle, never blooms at this alpha)
            renderer.polygon(base, stroke=scale_rgb(col, 1.35, alpha=0.45))
            # additive afterglow lingering after a capture
            if fx.afterglow > 0.003:
                hi = highlight_colour(owner)
                renderer.polygon(base, fill=(hi[0], hi[1], hi[2], min(1.0, fx.afterglow)), blend="add")
        last = board.last_placed
        if last is not None:
            centre = hex_to_pixel(last, self.origin, sz)
            ring = self._verts(centre, _HEX_GAP * self.fx[last].scale)
            renderer.polygon(ring, stroke=LAST_OUTLINE)