menu.py

Part of Bloom.

"""Bloom menus: main menu (mode + difficulty) and the how-to-play card.

Both are anchored, resize-aware UI built from SimVX widgets. The how-to card
runs a looping live demo of the one rule by reusing the real board, resolver
and :class:`HexBoardView`, so the tutorial can never drift from the game. The
root parents the card under a CanvasLayer, which pins it to the window.
"""

import math

import render
from ai import DIFFICULTY_BLURB
from board import CENTRE, Board, Owner, resolve_placement
from hex_grid import Hex, hex_corners, hex_in_range
from render import HexBoardView

from simvx.core import (
    Anchor,
    Button,
    HBoxContainer,
    Label,
    Node2D,
    Signal,
    SizingMode,
    VBoxContainer,
    Vec2,
    tween,
    wait,
)
from simvx.core.animation.tween import ease_out_back

TITLE = (1.0, 0.72, 0.42, 1.0)
TEXT = (0.93, 0.94, 0.97, 1.0)
TEXT_DIM = (0.62, 0.65, 0.74, 1.0)
BTN_BG = (0.16, 0.18, 0.24, 1.0)
BTN_HOVER = (0.22, 0.26, 0.34, 1.0)
BTN_DOWN = (0.12, 0.14, 0.19, 1.0)
SEL_BG = (0.30, 0.34, 0.46, 1.0)
PLAY_BG = (0.62, 0.34, 0.16, 1.0)
PLAY_HOVER = (0.74, 0.42, 0.20, 1.0)


def make_button(
    text, width=0.0, height=0.0, *, font=18.0, bg=BTN_BG, hover=BTN_HOVER, down=BTN_DOWN, fg=TEXT
) -> Button:
    """Themed :class:`Button` factory shared by every Bloom screen.

    ``width`` / ``height`` may be left at 0 when a container sizes the button.
    """
    b = Button(text)
    b.size = Vec2(width, height)
    b.font_size = font
    b.bg_colour = bg
    b.hover_colour = hover
    b.pressed_colour = down
    b.text_colour = fg
    b.border_colour = (0.30, 0.33, 0.42, 1.0)
    return b


class _Segmented:
    """A row of mutually-exclusive option buttons."""

    def __init__(self, options: list[tuple[str, str]], default: str, on_change):
        self.options = options
        self.value = default
        self._on_change = on_change
        self.buttons: dict[str, Button] = {}
        self.row = HBoxContainer()
        self.row.separation = 6
        self.row.sizing = SizingMode.FILL  # the row shares its width evenly, at any size

    def build(self, total_w: float, h: float) -> HBoxContainer:
        for key, label in self.options:
            b = make_button(label, height=h, font=15.0)
            b.pressed.connect(lambda k=key: self.select(k))
            self.buttons[key] = b
            self.row.add_child(b)
        self.row.size = Vec2(total_w, h)
        self._restyle()
        return self.row

    def select(self, key: str):
        if key == self.value:
            return
        self.value = key
        self._restyle()
        self._on_change(key)

    def set_enabled(self, enabled: bool):
        for b in self.buttons.values():
            b.bg_colour = BTN_BG if enabled else (0.12, 0.12, 0.15, 1.0)
            b.text_colour = TEXT if enabled else TEXT_DIM
        if enabled:
            self._restyle()

    def _restyle(self):
        for key, b in self.buttons.items():
            sel = key == self.value
            b.bg_colour = SEL_BG if sel else BTN_BG
            b.text_colour = (1.0, 1.0, 1.0, 1.0) if sel else TEXT


class MainMenu(Node2D):
    """Title, mode/difficulty selectors and Play. Emits configuration on start."""

    start_requested = Signal(object)  # dict: {"mode", "difficulty"}
    help_requested = Signal()
    quit_requested = Signal()

    def __init__(self, show_quit: bool = True, **kw):
        super().__init__(name="MainMenu", **kw)
        self._show_quit = show_quit
        self.mode = "ai"
        self.difficulty = "sharp"
        self._mode_seg: _Segmented | None = None
        self._diff_seg: _Segmented | None = None
        self._diff_label: Label | None = None
        self._root: VBoxContainer | None = None
        self._enter = 0.0  # title entrance 0 -> 1 (eased), persists across resizes

    def on_ready(self):
        self._rebuild()
        self.tree.screen_resized.connect(self._on_resize)
        self.start_coroutine(tween(self, "_enter", 1.0, 0.55, easing=ease_out_back))

    def on_update(self, dt):
        self.queue_redraw()  # drawn title + living backdrop animate every frame

    def _on_resize(self, *_):
        if self._root is not None:
            self._root.destroy()
            self._root = None
        self._rebuild()

    def _screen_w(self) -> float:
        return render.screen_wh(self.tree)[0]

    def _rebuild(self):
        w = self._screen_w()
        col = max(280.0, min(w * 0.7, 440.0))
        root = VBoxContainer(name="MenuCol", anchor=Anchor.CENTER, size=(col, 500))
        root.separation = 12

        # The "BLOOM" title is drawn in on_draw (animated glow + entrance); reserve
        # its slot here so the column layout is unchanged.
        root.add_child(self._spacer(col, 90))

        tag = Label("Grow your colour. Starve theirs.")
        tag.font_size = 15.0
        tag.text_colour = TEXT_DIM
        tag.alignment = "centre"
        tag.size = Vec2(col, 22)
        root.add_child(tag)

        root.add_child(self._spacer(col, 10))

        self._mode_seg = _Segmented([("ai", "vs Computer"), ("hotseat", "2 Players")], self.mode, self._set_mode)
        root.add_child(self._mode_seg.build(col, 46))

        self._diff_seg = _Segmented(
            [("calm", "Calm"), ("sharp", "Sharp"), ("ruthless", "Ruthless")], self.difficulty, self._set_difficulty
        )
        root.add_child(self._diff_seg.build(col, 46))

        self._diff_label = Label(DIFFICULTY_BLURB[self.difficulty])
        self._diff_label.font_size = 13.0
        self._diff_label.text_colour = TEXT_DIM
        self._diff_label.alignment = "centre"
        self._diff_label.size = Vec2(col, 20)
        root.add_child(self._diff_label)

        root.add_child(self._spacer(col, 8))

        play = make_button(
            "PLAY", col, 58, font=24.0, bg=PLAY_BG, hover=PLAY_HOVER, down=(0.50, 0.27, 0.12, 1.0), fg=(1, 1, 1, 1)
        )
        play.pressed.connect(self._on_play)
        root.add_child(play)

        how = make_button("How to play", col, 40, font=15.0)
        how.pressed.connect(self.help_requested.emit)
        root.add_child(how)

        if self._show_quit:
            quit_btn = make_button("Quit", col, 36, font=14.0, fg=TEXT_DIM)
            quit_btn.pressed.connect(self.quit_requested.emit)
            root.add_child(quit_btn)

        self._apply_mode_state()
        self.add_child(root)
        self._root = root

    def _spacer(self, w, h) -> Label:
        s = Label("")
        s.size = Vec2(w, h)
        return s

    def _set_mode(self, mode):
        self.mode = mode
        self._apply_mode_state()

    def _set_difficulty(self, diff):
        self.difficulty = diff
        if self._diff_label:
            self._diff_label.text = DIFFICULTY_BLURB[diff]

    def _apply_mode_state(self):
        if self._diff_seg:
            self._diff_seg.set_enabled(self.mode == "ai")

    def _on_play(self):
        self.start_requested.emit({"mode": self.mode, "difficulty": self.difficulty})

    def on_draw(self, renderer):
        w, h = render.screen_wh(self.tree)
        now = self.tree.now
        # living backdrop: a few big, faint, slowly breathing blooms behind the menu
        blooms = (
            (w * 0.16, h * 0.32, render.WARM, 0.0),
            (w * 0.85, h * 0.62, render.COOL, 2.1),
            (w * 0.52, h * 0.9, render.WARM, 4.0),
        )
        plen = min(w, h) * 0.13
        for bx, by, col, ph in blooms:
            breath = 1.0 + 0.10 * math.sin(now * 0.5 + ph)
            render.draw_flower(renderer, bx, by, plen * breath, (col[0], col[1], col[2], 0.04))
        # the hero title: entrance scale/fade + gentle breathing + a soft warm glow
        e = max(0.0, min(1.0, self._enter))
        cx, cy = w / 2.0, h / 2.0 - 205.0
        px = max(54.0, min(w * 0.10, 96.0))
        breath = 1.0 + 0.02 * math.sin(now * 1.7)
        sc = (px / 16.0) * (0.9 + 0.1 * self._enter) * breath
        # soft 3-ring additive aura (falloff, not a hard orb)
        glow = (1.0, 0.66, 0.34)
        gb = 1.0 + 0.05 * math.sin(now * 1.7)
        for gr, ga in ((0.55, 0.14), (0.95, 0.08), (1.4, 0.04)):
            render.draw_disc(renderer, cx, cy, px * gr * gb, (glow[0], glow[1], glow[2], ga * e))
        renderer.text(
            "BLOOM",
            fill=(TITLE[0], TITLE[1], TITLE[2], e),
            scale=sc,
            align="centre",
            valign="centre",
            rect=(0, cy - px, w, 2 * px),
        )


def demo_rect(tree) -> tuple[float, float, float]:
    """The how-to card's mini-board rect as ``(x, y, side)``, from the live viewport."""
    w, h = render.screen_wh(tree)
    side = min(w * 0.6, h * 0.32)
    return w / 2 - side / 2, h * 0.17, side


class RuleDemo(Node2D):
    """The looping live demo of the one rule, inside the how-to card.

    Its own node because it is the one part of the card that belongs in the
    post-processed lane: owned cores sit above 1.0 so the garden's bloom catches
    them here exactly as it does on the real board, and ``post_processed=True``
    asks for that lane. Placement still comes from the CanvasLayer above the card, so
    this draws in window coordinates like everything else on it.
    """

    def __init__(self, **kw):
        super().__init__(name="RuleDemo", post_processed=True, **kw)
        self.board = Board(radius=1)
        self.view = HexBoardView()

    def on_ready(self):
        self._reset()
        self.start_coroutine(self._loop())

    def on_update(self, dt):
        self.queue_redraw()  # the board cells are plain state, not Properties

    def _reset(self):
        self.board.cells = dict.fromkeys(hex_in_range(CENTRE, 1), Owner.EMPTY)
        self.board.cells[CENTRE] = Owner.COOL
        self.board.cells[Hex(1, 0)] = Owner.WARM
        self.board.last_placed = None
        self.view.sync_static(self.board)

    def _loop(self):
        while True:
            yield from wait(1.1)
            seed = Hex(-1, 1)
            if self.board.cells.get(seed) is Owner.EMPTY:
                resolve_placement(self.board, seed, Owner.WARM)
                self.view.sync_static(self.board)
            yield from wait(1.6)
            self._reset()

    def on_draw(self, renderer):
        x, y, side = demo_rect(self.tree)
        self.view.layout(self.board, x, y, side, side)
        self.view.draw(renderer, self.board)


class HowToCard(Node2D):
    """The how-to screen: dimming scrim, rule text, legend and a live demo.

    The root parents this under a CanvasLayer, so everything it draws is pinned
    to the window and composited after tonemap, clear of the board's bloom and
    grain. The live demo is the one child that opts back into that lane.
    """

    back_requested = Signal()

    def on_ready(self):
        self.add_child(RuleDemo())
        back = make_button("Back", font=18.0)
        back.size = Vec2(300, 48)
        back.inset = (0, 16)
        back.anchor = Anchor.CENTER_BOTTOM
        back.pressed.connect(self.back_requested.emit)
        self.add_child(back)

    def on_update(self, dt):
        self.queue_redraw()  # the card re-fits the viewport every frame

    def on_draw(self, renderer):
        w, h = render.screen_wh(self.tree)
        renderer.rect((0, 0), (w, h), fill=(0.04, 0.05, 0.07, 0.82))
        renderer.text("How to play", (w / 2, h * 0.10), fill=TITLE, scale=1.8, align="centre")
        _, demo_top, side = demo_rect(self.tree)
        # legend row, centred under the demo
        ly = demo_top + side + 26
        self._legend(renderer, w / 2 - 150, ly, render.WARM, "You")
        self._legend(renderer, w / 2 - 24, ly, render.COOL, "Opponent")
        self._legend(renderer, w / 2 + 118, ly, render.EMPTY, "Empty")
        # rule text, width-fitted so it never overflows on phones
        rules = [
            ("Press an empty hex to aim; release to place a seed.", TEXT, 0.95),
            ("Capture rule: count only the cells TOUCHING a hex. An enemy hex flips", TEXT_DIM, 0.9),
            ("when your seeds touching it outnumber its own. Then captures ripple out.", TEXT_DIM, 0.9),
            ("Your hexes flip the same way on their turn, so keep yours connected.", TEXT_DIM, 0.9),
        ]
        for i, (line, colour, scale) in enumerate(rules):
            renderer.text(
                line,
                fill=colour,
                scale=scale,
                align="centre",
                rect=(20, ly + 26 + i * 22, w - 40, 22),
                fit_to_width=True,
            )

    def _legend(self, renderer, x, y, colour, text):
        renderer.polygon([(c.x, c.y) for c in hex_corners(Vec2(x, y), 10)], fill=colour)
        renderer.text(text, (x + 16, y), fill=TEXT, scale=0.8, align="left", valign="centre")