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.
"""

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 (
    AnchorPreset,
    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")
        root.set_anchor_preset(AnchorPreset.CENTER)
        root.margin_left = -col / 2
        root.margin_right = col / 2
        root.margin_top = -250
        root.margin_bottom = 250
        root.size = Vec2(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 = "center"
        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 = "center"
        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.draw_text(
            "BLOOM",
            rect=(0, cy - px, w, 2 * px),
            colour=(TITLE[0], TITLE[1], TITLE[2], e),
            scale=sc,
            alignment="centre",
            vertical_alignment="centre",
            screen_space=True,
        )


class HowToCard(Node2D):
    """Looping live demo of the one rule plus a legend. Reuses the real engine."""

    back_requested = Signal()

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

    def on_ready(self):
        self._reset_demo()
        self.start_coroutine(self._loop())
        back = make_button("Back", font=18.0)
        back.set_anchor_preset(AnchorPreset.CENTER_BOTTOM)
        back.margin_left = -150
        back.margin_right = 150
        back.margin_top = -64
        back.margin_bottom = -16
        back.size = Vec2(300, 48)
        back.pressed.connect(self.back_requested.emit)
        self.add_child(back)

    def on_update(self, dt):
        self.queue_redraw()  # dynamic on_draw (animated demo + non-Property text)

    def _reset_demo(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_demo()

    def on_draw(self, renderer):
        w, h = render.screen_wh(self.tree)
        renderer.draw_rect((0, 0), (w, h), colour=(0.04, 0.05, 0.07, 0.82), filled=True, screen_space=True)
        renderer.draw_text(
            "How to play", (w / 2, h * 0.10), colour=TITLE, scale=1.8, alignment="centre", screen_space=True
        )
        dh = min(w * 0.6, h * 0.32)
        demo_top = h * 0.17
        self.view.layout(self.board, w / 2 - dh / 2, demo_top, dh, dh)
        self.view.draw(renderer, self.board)
        # legend row, centred under the demo
        ly = demo_top + dh + 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.draw_text(
                line,
                rect=(20, ly + 26 + i * 22, w - 40, 22),
                colour=colour,
                scale=scale,
                alignment="centre",
                fit_to_width=True,
                screen_space=True,
            )

    def _legend(self, renderer, x, y, colour, text):
        renderer.draw_polygon([(c.x, c.y) for c in hex_corners(Vec2(x, y), 10)], colour=colour, filled=True)
        renderer.draw_text(
            text, (x + 16, y), colour=TEXT, scale=0.8, alignment="left", vertical_alignment="centre", screen_space=True
        )