Jeu Snake en Python : crée Snake Néon avec Pygame (tutoriel complet 2026)

git clone https://github.com/LM-Code-Be/snake-game.git
cd snake-game

git clone https://github.com/LM-Code-Be/snake-game.git
cd snake-game

python -m venv .venv
# Windows
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate

pip install -r requirements.txt

python -m venv .venv
# Windows
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate

pip install -r requirements.txt

python main.py

python main.py

tant que le jeu tourne :
    1. lire les événements   (touches pressées, souris, fermeture de la fenêtre)
    2. mettre à jour         (déplacer le serpent, vérifier les collisions, animer...)
    3. dessiner              (effacer l'écran, tout redessiner, afficher)

tant que le jeu tourne :
    1. lire les événements   (touches pressées, souris, fermeture de la fenêtre)
    2. mettre à jour         (déplacer le serpent, vérifier les collisions, animer...)
    3. dessiner              (effacer l'écran, tout redessiner, afficher)

import pygame

pygame.init()
ecran = pygame.display.set_mode((640, 480))   # crée la fenêtre
horloge = pygame.time.Clock()

en_cours = True
while en_cours:
    for event in pygame.event.get():            # 1. événements
        if event.type == pygame.QUIT:
            en_cours = False
    # 2. mise à jour : rien ici
    ecran.fill((20, 20, 40))                    # 3. dessin : on remplit l'écran
    pygame.draw.circle(ecran, (0, 255, 200), (320, 240), 40)
    pygame.display.flip()                       # on affiche l'image dessinée
    horloge.tick(60)                            # on limite à 60 images par seconde

pygame.quit()

import pygame

pygame.init()
ecran = pygame.display.set_mode((640, 480))   # crée la fenêtre
horloge = pygame.time.Clock()

en_cours = True
while en_cours:
    for event in pygame.event.get():            # 1. événements
        if event.type == pygame.QUIT:
            en_cours = False
    # 2. mise à jour : rien ici
    ecran.fill((20, 20, 40))                    # 3. dessin : on remplit l'écran
    pygame.draw.circle(ecran, (0, 255, 200), (320, 240), 40)
    pygame.display.flip()                       # on affiche l'image dessinée
    horloge.tick(60)                            # on limite à 60 images par seconde

pygame.quit()

snake-game/
├── main.py                  Lance le jeu
├── requirements.txt         Dépendances (pygame)
└── snake_game/              Le package du jeu
    ├── config.py            Constantes et réglages
    ├── ui.py                Outils de dessin et d'interface
    ├── database.py          Sauvegarde SQLite
    ├── audio.py             Synthèse sonore
    ├── effects.py           Particules, fond animé, transitions
    ├── entities.py          Le serpent et les objets
    ├── levels.py            Les niveaux
    ├── renderer.py          Dessin du plateau et du serpent
    ├── app.py               La boucle principale
    └── scenes/              Les « écrans » du jeu
        ├── base.py          Classe commune à tous les écrans
        ├── menu.py          Menu principal
        ├── game.py          La partie elle-même
        ├── gameover.py      Fin de partie
        ├── level_select.py  Choix du niveau
        ├── scores.py        Classements et statistiques
        ├── settings.py      Paramètres
        └── help.py          Aide

snake-game/
├── main.py                  Lance le jeu
├── requirements.txt         Dépendances (pygame)
└── snake_game/              Le package du jeu
    ├── config.py            Constantes et réglages
    ├── ui.py                Outils de dessin et d'interface
    ├── database.py          Sauvegarde SQLite
    ├── audio.py             Synthèse sonore
    ├── effects.py           Particules, fond animé, transitions
    ├── entities.py          Le serpent et les objets
    ├── levels.py            Les niveaux
    ├── renderer.py          Dessin du plateau et du serpent
    ├── app.py               La boucle principale
    └── scenes/              Les « écrans » du jeu
        ├── base.py          Classe commune à tous les écrans
        ├── menu.py          Menu principal
        ├── game.py          La partie elle-même
        ├── gameover.py      Fin de partie
        ├── level_select.py  Choix du niveau
        ├── scores.py        Classements et statistiques
        ├── settings.py      Paramètres
        └── help.py          Aide

python --version

python --version

mkdir snake-game
cd snake-game
python -m venv .venv

mkdir snake-game
cd snake-game
python -m venv .venv

# Windows
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate

# Windows
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate

pygame>=2.5

pygame>=2.5

pip install -r requirements.txt

pip install -r requirements.txt

"""Snake Néon : un jeu de Snake complet avec Pygame."""

"""Snake Néon : un jeu de Snake complet avec Pygame."""

"""Scènes du jeu (écrans)."""

"""Scènes du jeu (écrans)."""

.venv/
__pycache__/
data/

.venv/
__pycache__/
data/

"""Configuration globale : fenêtre, grille, vitesses, difficultés, thèmes et bonus."""
from pathlib import Path

# --- Chemins -----------------------------------------------------------------
BASE_DIR = Path(__file__).resolve().parent.parent
DATA_DIR = BASE_DIR / "data"
DB_PATH = DATA_DIR / "snake.db"

# --- Fenêtre -----------------------------------------------------------------
TITLE = "Snake Néon"
VERSION = "1.0"
DEFAULT_WINDOW = (1280, 760)
REFERENCE_SIZE = (1280, 720)   # taille de référence pour l'échelle de l'interface
FPS = 120

# --- Grille de jeu -------------------------------------------------------------
COLS, ROWS = 32, 20

UP, DOWN, LEFT, RIGHT = (0, -1), (0, 1), (-1, 0), (1, 0)
OPPOSITE = {UP: DOWN, DOWN: UP, LEFT: RIGHT, RIGHT: LEFT}

# --- Règles --------------------------------------------------------------------
ADVENTURE_LIVES = 3
CLASSIC_LIVES = 1
COMBO_WINDOW = 2.5          # secondes pour enchaîner un combo
MAX_COMBO = 5
GOLDEN_CHANCE = 0.14        # probabilité d'une pomme dorée après chaque pomme
POWERUP_CHANCE = 0.20       # probabilité d'un bonus après chaque pomme
GOLDEN_TTL = 6.0
POWERUP_TTL = 8.0

DIFFICULTIES = {
    "facile":    {"label": "Facile",    "speed": 0.80, "score": 0.75},
    "normal":    {"label": "Normal",    "speed": 1.00, "score": 1.00},
    "difficile": {"label": "Difficile", "speed": 1.25, "score": 1.50},
}
DIFFICULTY_ORDER = ["facile", "normal", "difficile"]

# --- Bonus ---------------------------------------------------------------------
GOLD = (255, 205, 60)
POWERUPS = {
    "slow":   {"label": "Ralenti",  "color": (80, 170, 255),  "duration": 6.0,
               "desc": "Le temps ralentit pendant 6 s."},
    "ghost":  {"label": "Fantôme",  "color": (190, 120, 255), "duration": 6.0,
               "desc": "Traversez murs et queue pendant 6 s."},
    "double": {"label": "Score x2", "color": (255, 110, 200), "duration": 8.0,
               "desc": "Tous les points sont doublés pendant 8 s."},
    "shrink": {"label": "Rétrécir", "color": (70, 235, 210),  "duration": 0.0,
               "desc": "Le serpent perd 3 anneaux."},
}

# --- Thèmes de couleurs --------------------------------------------------------
THEMES = {
    "neon": {
        "label": "Néon",
        "bg_top": (12, 9, 30), "bg_bottom": (38, 12, 60),
        "board": (20, 16, 42), "board_alt": (25, 20, 50), "grid": (42, 36, 74),
        "panel": (32, 25, 64),
        "snake_head": (0, 255, 200), "snake_tail": (150, 70, 255),
        "accent": (0, 225, 255), "accent2": (255, 60, 180),
        "text": (240, 240, 255), "text_dim": (150, 148, 195),
        "obstacle": (92, 72, 158), "obstacle_light": (150, 128, 220),
        "food": (255, 70, 110), "danger": (255, 70, 95),
    },
    "ocean": {
        "label": "Océan",
        "bg_top": (4, 16, 34), "bg_bottom": (6, 44, 76),
        "board": (8, 28, 52), "board_alt": (10, 34, 60), "grid": (26, 62, 94),
        "panel": (12, 42, 70),
        "snake_head": (100, 245, 255), "snake_tail": (20, 105, 225),
        "accent": (60, 205, 255), "accent2": (255, 200, 80),
        "text": (230, 245, 255), "text_dim": (130, 170, 205),
        "obstacle": (30, 82, 124), "obstacle_light": (64, 136, 186),
        "food": (255, 120, 90), "danger": (255, 95, 95),
    },
    "foret": {
        "label": "Forêt",
        "bg_top": (7, 20, 12), "bg_bottom": (20, 46, 26),
        "board": (14, 32, 20), "board_alt": (17, 38, 24), "grid": (34, 64, 42),
        "panel": (22, 48, 30),
        "snake_head": (195, 255, 90), "snake_tail": (30, 160, 85),
        "accent": (150, 240, 110), "accent2": (255, 210, 90),
        "text": (235, 250, 230), "text_dim": (150, 190, 150),
        "obstacle": (86, 72, 50), "obstacle_light": (138, 118, 82),
        "food": (255, 80, 70), "danger": (255, 95, 70),
    },
    "crepuscule": {
        "label": "Crépuscule",
        "bg_top": (28, 8, 20), "bg_bottom": (74, 24, 42),
        "board": (40, 14, 28), "board_alt": (47, 18, 33), "grid": (76, 36, 56),
        "panel": (58, 20, 38),
        "snake_head": (255, 215, 95), "snake_tail": (255, 70, 125),
        "accent": (255, 150, 80), "accent2": (140, 200, 255),
        "text": (255, 240, 235), "text_dim": (205, 150, 162),
        "obstacle": (104, 42, 72), "obstacle_light": (165, 74, 114),
        "food": (120, 255, 170), "danger": (255, 85, 85),
    },
}
THEME_ORDER = ["neon", "ocean", "foret", "crepuscule"]
for _key, _theme in THEMES.items():
    _theme["name"] = _key

# --- Paramètres par défaut (persistés en base) ---------------------------------
DEFAULT_SETTINGS = {
    "player": "Joueur",
    "difficulty": "normal",
    "theme": "neon",
    "music_volume": 5,
    "sfx_volume": 8,
    "show_grid": True,
    "screen_shake": True,
    "fullscreen": False,
    "show_fps": False,
}

"""Configuration globale : fenêtre, grille, vitesses, difficultés, thèmes et bonus."""
from pathlib import Path

# --- Chemins -----------------------------------------------------------------
BASE_DIR = Path(__file__).resolve().parent.parent
DATA_DIR = BASE_DIR / "data"
DB_PATH = DATA_DIR / "snake.db"

# --- Fenêtre -----------------------------------------------------------------
TITLE = "Snake Néon"
VERSION = "1.0"
DEFAULT_WINDOW = (1280, 760)
REFERENCE_SIZE = (1280, 720)   # taille de référence pour l'échelle de l'interface
FPS = 120

# --- Grille de jeu -------------------------------------------------------------
COLS, ROWS = 32, 20

UP, DOWN, LEFT, RIGHT = (0, -1), (0, 1), (-1, 0), (1, 0)
OPPOSITE = {UP: DOWN, DOWN: UP, LEFT: RIGHT, RIGHT: LEFT}

# --- Règles --------------------------------------------------------------------
ADVENTURE_LIVES = 3
CLASSIC_LIVES = 1
COMBO_WINDOW = 2.5          # secondes pour enchaîner un combo
MAX_COMBO = 5
GOLDEN_CHANCE = 0.14        # probabilité d'une pomme dorée après chaque pomme
POWERUP_CHANCE = 0.20       # probabilité d'un bonus après chaque pomme
GOLDEN_TTL = 6.0
POWERUP_TTL = 8.0

DIFFICULTIES = {
    "facile":    {"label": "Facile",    "speed": 0.80, "score": 0.75},
    "normal":    {"label": "Normal",    "speed": 1.00, "score": 1.00},
    "difficile": {"label": "Difficile", "speed": 1.25, "score": 1.50},
}
DIFFICULTY_ORDER = ["facile", "normal", "difficile"]

# --- Bonus ---------------------------------------------------------------------
GOLD = (255, 205, 60)
POWERUPS = {
    "slow":   {"label": "Ralenti",  "color": (80, 170, 255),  "duration": 6.0,
               "desc": "Le temps ralentit pendant 6 s."},
    "ghost":  {"label": "Fantôme",  "color": (190, 120, 255), "duration": 6.0,
               "desc": "Traversez murs et queue pendant 6 s."},
    "double": {"label": "Score x2", "color": (255, 110, 200), "duration": 8.0,
               "desc": "Tous les points sont doublés pendant 8 s."},
    "shrink": {"label": "Rétrécir", "color": (70, 235, 210),  "duration": 0.0,
               "desc": "Le serpent perd 3 anneaux."},
}

# --- Thèmes de couleurs --------------------------------------------------------
THEMES = {
    "neon": {
        "label": "Néon",
        "bg_top": (12, 9, 30), "bg_bottom": (38, 12, 60),
        "board": (20, 16, 42), "board_alt": (25, 20, 50), "grid": (42, 36, 74),
        "panel": (32, 25, 64),
        "snake_head": (0, 255, 200), "snake_tail": (150, 70, 255),
        "accent": (0, 225, 255), "accent2": (255, 60, 180),
        "text": (240, 240, 255), "text_dim": (150, 148, 195),
        "obstacle": (92, 72, 158), "obstacle_light": (150, 128, 220),
        "food": (255, 70, 110), "danger": (255, 70, 95),
    },
    "ocean": {
        "label": "Océan",
        "bg_top": (4, 16, 34), "bg_bottom": (6, 44, 76),
        "board": (8, 28, 52), "board_alt": (10, 34, 60), "grid": (26, 62, 94),
        "panel": (12, 42, 70),
        "snake_head": (100, 245, 255), "snake_tail": (20, 105, 225),
        "accent": (60, 205, 255), "accent2": (255, 200, 80),
        "text": (230, 245, 255), "text_dim": (130, 170, 205),
        "obstacle": (30, 82, 124), "obstacle_light": (64, 136, 186),
        "food": (255, 120, 90), "danger": (255, 95, 95),
    },
    "foret": {
        "label": "Forêt",
        "bg_top": (7, 20, 12), "bg_bottom": (20, 46, 26),
        "board": (14, 32, 20), "board_alt": (17, 38, 24), "grid": (34, 64, 42),
        "panel": (22, 48, 30),
        "snake_head": (195, 255, 90), "snake_tail": (30, 160, 85),
        "accent": (150, 240, 110), "accent2": (255, 210, 90),
        "text": (235, 250, 230), "text_dim": (150, 190, 150),
        "obstacle": (86, 72, 50), "obstacle_light": (138, 118, 82),
        "food": (255, 80, 70), "danger": (255, 95, 70),
    },
    "crepuscule": {
        "label": "Crépuscule",
        "bg_top": (28, 8, 20), "bg_bottom": (74, 24, 42),
        "board": (40, 14, 28), "board_alt": (47, 18, 33), "grid": (76, 36, 56),
        "panel": (58, 20, 38),
        "snake_head": (255, 215, 95), "snake_tail": (255, 70, 125),
        "accent": (255, 150, 80), "accent2": (140, 200, 255),
        "text": (255, 240, 235), "text_dim": (205, 150, 162),
        "obstacle": (104, 42, 72), "obstacle_light": (165, 74, 114),
        "food": (120, 255, 170), "danger": (255, 85, 85),
    },
}
THEME_ORDER = ["neon", "ocean", "foret", "crepuscule"]
for _key, _theme in THEMES.items():
    _theme["name"] = _key

# --- Paramètres par défaut (persistés en base) ---------------------------------
DEFAULT_SETTINGS = {
    "player": "Joueur",
    "difficulty": "normal",
    "theme": "neon",
    "music_volume": 5,
    "sfx_volume": 8,
    "show_grid": True,
    "screen_shake": True,
    "fullscreen": False,
    "show_fps": False,
}

_scale = min(largeur / 1280, hauteur / 720)

_scale = min(largeur / 1280, hauteur / 720)

ui.draw_text(surf, "PAUSE", S(48), ...)   # 48 px en 1280x720, 72 px en 1920x1080

ui.draw_text(surf, "PAUSE", S(48), ...)   # 48 px en 1280x720, 72 px en 1920x1080

"""Outils d'interface : échelle responsive, polices, couleurs, formes, boutons et menus."""
import math

import pygame

from .config import REFERENCE_SIZE

# --- Échelle responsive ----------------------------------------------------------
# Toute l'interface est pensée pour 1280x720 puis multipliée par ce facteur.
_scale = 1.0


def set_scale(width, height):
    global _scale
    _scale = max(0.5, min(width / REFERENCE_SIZE[0], height / REFERENCE_SIZE[1]))


def S(value):
    """Convertit une taille « de référence » en pixels réels."""
    return int(round(value * _scale))


# --- Maths & couleurs -------------------------------------------------------------
def clamp(v, lo=0.0, hi=1.0):
    return lo if v < lo else hi if v > hi else v


def lerp(a, b, t):
    return a + (b - a) * t


def lerp_color(c1, c2, t):
    t = clamp(t)
    return (int(c1[0] + (c2[0] - c1[0]) * t),
            int(c1[1] + (c2[1] - c1[1]) * t),
            int(c1[2] + (c2[2] - c1[2]) * t))


def lighten(color, amount):
    return lerp_color(color, (255, 255, 255), amount)


def darken(color, amount):
    return lerp_color(color, (0, 0, 0), amount)


def ease_out_cubic(t):
    t = clamp(t)
    return 1 - (1 - t) ** 3


def ease_in_out(t):
    t = clamp(t)
    return 3 * t * t - 2 * t * t * t


def ease_out_back(t):
    t = clamp(t)
    c1, c3 = 1.70158, 2.70158
    return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2


# --- Polices & texte ----------------------------------------------------------------
FONT_NAMES = "bahnschrift,segoeui,verdana,dejavusans,arial"
# Police de secours pour les symboles (flèches, étoiles) absents de la police principale.
SYMBOL_FONT_NAMES = "segoeuisymbol,seguisym,dejavusans,arial"
_fonts = {}
_text_cache = {}


def font(size, bold=False, symbols=False):
    key = (size, bold, symbols)
    if key not in _fonts:
        names = SYMBOL_FONT_NAMES if symbols else FONT_NAMES
        _fonts[key] = pygame.font.SysFont(names, max(8, size), bold=bold and not symbols)
    return _fonts[key]


def _is_symbol(ch):
    return ord(ch) >= 0x2190


def render_text(text, size, color, bold=False):
    key = (text, size, color, bold)
    surf = _text_cache.get(key)
    if surf is None:
        if len(_text_cache) > 800:
            _text_cache.clear()
        if not any(_is_symbol(ch) for ch in text):
            surf = font(size, bold).render(text, True, color)
        else:
            # Découpe en segments « texte » / « symboles » rendus chacun avec sa police.
            runs, current, sym = [], "", None
            for ch in text:
                if sym is not None and _is_symbol(ch) != sym:
                    runs.append((current, sym))
                    current = ""
                current += ch
                sym = _is_symbol(ch)
            runs.append((current, sym))
            parts = [font(size, bold, s).render(t, True, color) for t, s in runs]
            height = max(p.get_height() for p in parts)
            surf = pygame.Surface((sum(p.get_width() for p in parts), height), pygame.SRCALPHA)
            x = 0
            for p in parts:
                surf.blit(p, (x, (height - p.get_height()) // 2))
                x += p.get_width()
        _text_cache[key] = surf
    return surf


def draw_text(surf, text, size, color, pos, anchor="center", bold=False,
              shadow=True, alpha=255):
    """Dessine un texte (taille déjà en pixels) et renvoie son rectangle."""
    img = render_text(text, size, color, bold)
    rect = img.get_rect(**{anchor: (int(pos[0]), int(pos[1]))})
    if shadow:
        sh = render_text(text, size, (0, 0, 0), bold)
        sh.set_alpha(int(110 * alpha / 255))
        off = max(1, size // 18)
        surf.blit(sh, rect.move(off, off))
    img.set_alpha(alpha)
    surf.blit(img, rect)
    return rect


# --- Surfaces utilitaires -------------------------------------------------------------
def vertical_gradient(size, top, bottom):
    tiny = pygame.Surface((2, 2))
    tiny.fill(top)
    tiny.set_at((0, 1), bottom)
    tiny.set_at((1, 1), bottom)
    return pygame.transform.smoothscale(tiny, size)


_glow_cache = {}


def glow(radius, color):
    """Halo radial à blitter avec BLEND_ADD (rendu « néon »)."""
    radius = max(2, int(radius))
    key = (radius, color)
    surf = _glow_cache.get(key)
    if surf is None:
        if len(_glow_cache) > 400:
            _glow_cache.clear()
        surf = pygame.Surface((radius * 2, radius * 2))
        step = max(1, radius // 24)
        for r in range(radius, 0, -step):
            k = (1 - r / radius) ** 2
            pygame.draw.circle(surf, (int(color[0] * k), int(color[1] * k), int(color[2] * k)),
                               (radius, radius), r)
        _glow_cache[key] = surf
    return surf


def blit_glow(surf, center, radius, color):
    g = glow(radius, color)
    surf.blit(g, (center[0] - g.get_width() // 2, center[1] - g.get_height() // 2),
              special_flags=pygame.BLEND_ADD)


def draw_panel(surf, rect, color, alpha=230, radius=None, border=None, border_width=2):
    """Rectangle arrondi semi-transparent."""
    radius = S(16) if radius is None else radius
    panel = pygame.Surface(rect.size, pygame.SRCALPHA)
    pygame.draw.rect(panel, (*color, alpha), panel.get_rect(), border_radius=radius)
    if border:
        pygame.draw.rect(panel, border, panel.get_rect(), max(1, border_width), border_radius=radius)
    surf.blit(panel, rect.topleft)


def dim_screen(surf, alpha=150, color=(0, 0, 0)):
    veil = pygame.Surface(surf.get_size(), pygame.SRCALPHA)
    veil.fill((*color, alpha))
    surf.blit(veil, (0, 0))


# --- Formes ----------------------------------------------------------------------------
def draw_heart(surf, center, size, color):
    cx, cy = center
    r = size * 0.28
    pygame.draw.circle(surf, color, (cx - size * 0.24, cy - size * 0.08), r)
    pygame.draw.circle(surf, color, (cx + size * 0.24, cy - size * 0.08), r)
    pygame.draw.polygon(surf, color, [(cx - size * 0.5, cy), (cx + size * 0.5, cy),
                                      (cx, cy + size * 0.48)])


def star_points(center, radius, inner=0.45):
    pts = []
    for i in range(10):
        a = -math.pi / 2 + i * math.pi / 5
        r = radius if i % 2 == 0 else radius * inner
        pts.append((center[0] + math.cos(a) * r, center[1] + math.sin(a) * r))
    return pts


def draw_star(surf, center, radius, color, outline=None):
    pts = star_points(center, radius)
    pygame.draw.polygon(surf, color, pts)
    if outline:
        pygame.draw.polygon(surf, outline, pts, max(1, int(radius / 7)))


def draw_padlock(surf, center, size, color):
    cx, cy = center
    w, h = size * 0.7, size * 0.5
    body = pygame.Rect(0, 0, w, h)
    body.midtop = (cx, cy - size * 0.05)
    arc = pygame.Rect(0, 0, w * 0.7, size * 0.7)
    arc.midtop = (cx, cy - size * 0.42)
    pygame.draw.arc(surf, color, arc, 0, math.pi, max(2, int(size * 0.1)))
    pygame.draw.rect(surf, color, body, border_radius=max(2, int(size * 0.08)))


def draw_apple(surf, center, radius, color, leaf=(90, 210, 90)):
    cx, cy = center
    pygame.draw.circle(surf, darken(color, 0.25), (cx, cy), radius)
    pygame.draw.circle(surf, color, (cx - radius * 0.08, cy - radius * 0.1), radius * 0.88)
    pygame.draw.circle(surf, lighten(color, 0.55), (cx - radius * 0.38, cy - radius * 0.38),
                       max(1, radius * 0.2))
    pygame.draw.line(surf, (110, 70, 40), (cx, cy - radius * 0.8), (cx + radius * 0.15, cy - radius * 1.25),
                     max(2, int(radius * 0.16)))
    # Feuille : ellipse inclinée approximée par un polygone
    lx, ly, ang = cx + radius * 0.45, cy - radius * 1.05, -0.5
    pts = []
    for i in range(12):
        t = i / 12 * math.tau
        ex, ey = math.cos(t) * radius * 0.42, math.sin(t) * radius * 0.2
        pts.append((lx + ex * math.cos(ang) - ey * math.sin(ang), ly + ex * math.sin(ang) + ey * math.cos(ang)))
    pygame.draw.polygon(surf, leaf, pts)


def draw_powerup_icon(surf, kind, center, size, color, t=0.0):
    """Badge arrondi + pictogramme d'un bonus."""
    cx, cy = int(center[0]), int(center[1])
    rect = pygame.Rect(0, 0, int(size), int(size))
    rect.center = (cx, cy)
    pygame.draw.rect(surf, darken(color, 0.55), rect, border_radius=max(3, int(size * 0.28)))
    pygame.draw.rect(surf, color, rect, max(2, int(size * 0.08)), border_radius=max(3, int(size * 0.28)))
    white = (250, 250, 255)
    lw = max(2, int(size * 0.08))
    if kind == "slow":
        r = size * 0.27
        pygame.draw.circle(surf, white, (cx, cy), r, lw)
        a = t * 2.0
        pygame.draw.line(surf, white, (cx, cy), (cx, cy - r * 0.7), lw)
        pygame.draw.line(surf, white, (cx, cy), (cx + math.cos(a) * r * 0.6, cy + math.sin(a) * r * 0.6), lw)
    elif kind == "ghost":
        r = size * 0.22
        top = cy - size * 0.06
        pygame.draw.circle(surf, white, (cx, top), r)
        pygame.draw.rect(surf, white, (cx - r, top, r * 2, size * 0.24))
        for i in range(3):
            pygame.draw.circle(surf, white, (cx - r + r / 3 + i * r * 2 / 3, top + size * 0.24), r / 3)
        dark = darken(color, 0.6)
        pygame.draw.circle(surf, dark, (cx - r * 0.4, top), max(1, r * 0.22))
        pygame.draw.circle(surf, dark, (cx + r * 0.4, top), max(1, r * 0.22))
    elif kind == "shrink":
        s = size * 0.2
        pygame.draw.polygon(surf, white, [(cx - s * 1.6, cy - s), (cx - s * 0.3, cy), (cx - s * 1.6, cy + s)])
        pygame.draw.polygon(surf, white, [(cx + s * 1.6, cy - s), (cx + s * 0.3, cy), (cx + s * 1.6, cy + s)])
    elif kind == "double":
        draw_text(surf, "x2", max(8, int(size * 0.5)), white, (cx, cy), bold=True, shadow=False)


def make_icon():
    """Icône de fenêtre dessinée par le code (pas de fichier externe)."""
    icon = pygame.Surface((64, 64), pygame.SRCALPHA)
    pygame.draw.rect(icon, (20, 16, 42), icon.get_rect(), border_radius=14)
    pts = [(14, 46), (22, 46), (30, 46), (30, 38), (30, 30), (38, 30), (46, 30), (46, 22)]
    for i, p in enumerate(pts):
        col = lerp_color((150, 70, 255), (0, 255, 200), i / (len(pts) - 1))
        pygame.draw.circle(icon, col, p, 6)
    pygame.draw.circle(icon, (255, 70, 110), (46, 12), 5)
    return icon


# --- Boutons & menus ------------------------------------------------------------------------
class Button:
    def __init__(self, label, action, enabled=True, sub=None):
        self.label = label
        self.action = action
        self.enabled = enabled
        self.sub = sub
        self.rect = pygame.Rect(0, 0, 0, 0)
        self.hover = 0.0


class Menu:
    """Liste verticale de boutons pilotable au clavier et à la souris."""

    UP_KEYS = (pygame.K_UP, pygame.K_z, pygame.K_w)
    DOWN_KEYS = (pygame.K_DOWN, pygame.K_s)
    OK_KEYS = (pygame.K_RETURN, pygame.K_KP_ENTER, pygame.K_SPACE)

    def __init__(self, app, buttons, width=380, height=56, gap=12):
        self.app = app
        self.buttons = buttons
        self.width, self.height, self.gap = width, height, gap
        self.selected = next((i for i, b in enumerate(buttons) if b.enabled), 0)
        self.age = 0.0

    def total_height(self):
        n = len(self.buttons)
        return n * S(self.height) + (n - 1) * S(self.gap)

    def layout(self, cx, top):
        w, h, g = S(self.width), S(self.height), S(self.gap)
        for i, b in enumerate(self.buttons):
            b.rect = pygame.Rect(0, 0, w, h)
            b.rect.midtop = (cx, top + i * (h + g))

    def move(self, step):
        n = len(self.buttons)
        i = self.selected
        for _ in range(n):
            i = (i + step) % n
            if self.buttons[i].enabled:
                break
        if i != self.selected:
            self.selected = i
            self.app.audio.play("hover")

    def activate(self):
        button = self.buttons[self.selected]
        if button.enabled:
            self.app.audio.play("click")
            button.action()

    def handle_event(self, e):
        if e.type == pygame.KEYDOWN:
            if e.key in self.UP_KEYS:
                self.move(-1)
            elif e.key in self.DOWN_KEYS:
                self.move(1)
            elif e.key in self.OK_KEYS:
                self.activate()
                return True
        elif e.type == pygame.MOUSEMOTION:
            for i, b in enumerate(self.buttons):
                if b.enabled and b.rect.collidepoint(e.pos) and i != self.selected:
                    self.selected = i
                    self.app.audio.play("hover")
        elif e.type == pygame.MOUSEBUTTONDOWN and e.button == 1:
            for i, b in enumerate(self.buttons):
                if b.enabled and b.rect.collidepoint(e.pos):
                    self.selected = i
                    self.activate()
                    return True
        return False

    def update(self, dt):
        self.age += dt
        for i, b in enumerate(self.buttons):
            target = 1.0 if i == self.selected else 0.0
            b.hover += (target - b.hover) * min(1.0, dt * 14)

    def draw(self, surf, theme):
        for i, b in enumerate(self.buttons):
            appear = ease_out_cubic((self.age - i * 0.06) / 0.45)
            if appear <= 0:
                continue
            rect = b.rect.inflate(int(S(14) * b.hover), int(S(4) * b.hover))
            rect.x += int((1 - appear) * -S(90))
            draw_button(surf, rect, b, theme, int(255 * appear))


def draw_button(surf, rect, button, theme, alpha=255):
    pad = S(14)
    layer = pygame.Surface((rect.w + pad * 2, rect.h + pad * 2), pygame.SRCALPHA)
    inner = pygame.Rect(pad, pad, rect.w, rect.h)
    radius = S(14)
    h = button.hover if button.enabled else 0.0
    accent = theme["accent"]
    if h > 0.02:
        for k in range(3):
            g = inner.inflate(S(4) * (k + 1) * 2, S(4) * (k + 1) * 2)
            pygame.draw.rect(layer, (*accent, int(28 * h / (k + 1))), g, border_radius=radius + S(4) * (k + 1))
    fill = lerp_color(theme["panel"], darken(accent, 0.45), h)
    pygame.draw.rect(layer, (*fill, 235), inner, border_radius=radius)
    border = lerp_color(darken(accent, 0.5), accent, h)
    pygame.draw.rect(layer, (*border, 255), inner, max(1, S(2)), border_radius=radius)
    if button.enabled:
        color = lerp_color(theme["text_dim"], theme["text"], 0.45 + 0.55 * h)
    else:
        color = darken(theme["text_dim"], 0.45)
    if h > 0.05:
        s = S(7)
        x = inner.x + S(18) - int((1 - h) * S(10))
        cy = inner.centery
        pygame.draw.polygon(layer, (*accent, int(255 * h)), [(x, cy - s), (x + s, cy), (x, cy + s)])
    size = S(24)
    if button.sub:
        draw_text(layer, button.label, size, color, (inner.centerx, inner.centery - S(8)), bold=True)
        draw_text(layer, button.sub, S(15), theme["text_dim"], (inner.centerx, inner.centery + S(14)),
                  shadow=False)
    else:
        draw_text(layer, button.label, size, color, inner.center, bold=True)
    layer.set_alpha(alpha)
    surf.blit(layer, (rect.x - pad, rect.y - pad))


class TextInput:
    """Champ de saisie simple (nom du joueur)."""

    def __init__(self, text="", max_len=14):
        self.text = text
        self.max_len = max_len
        self.fresh = True   # la première frappe remplace le texte proposé

    def handle_event(self, e):
        if e.type == pygame.TEXTINPUT:
            if self.fresh:
                self.text = ""
                self.fresh = False
            for ch in e.text:
                if ch.isprintable() and len(self.text) < self.max_len:
                    self.text += ch
        elif e.type == pygame.KEYDOWN:
            if e.key == pygame.K_BACKSPACE:
                self.fresh = False
                self.text = self.text[:-1]
            elif e.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                return "submit"
        return None

    def draw(self, surf, rect, theme, time):
        draw_panel(surf, rect, darken(theme["panel"], 0.3), 240, S(12), theme["accent"], S(2))
        img = render_text(self.text, S(28), theme["text_dim"] if self.fresh else theme["text"], True)
        x = rect.centerx - img.get_width() // 2
        surf.blit(img, (x, rect.centery - img.get_height() // 2))
        if int(time * 2.2) % 2 == 0:
            cx = x + img.get_width() + S(4)
            pygame.draw.line(surf, theme["accent"], (cx, rect.centery - S(15)), (cx, rect.centery + S(15)), S(3))

"""Outils d'interface : échelle responsive, polices, couleurs, formes, boutons et menus."""
import math

import pygame

from .config import REFERENCE_SIZE

# --- Échelle responsive ----------------------------------------------------------
# Toute l'interface est pensée pour 1280x720 puis multipliée par ce facteur.
_scale = 1.0


def set_scale(width, height):
    global _scale
    _scale = max(0.5, min(width / REFERENCE_SIZE[0], height / REFERENCE_SIZE[1]))


def S(value):
    """Convertit une taille « de référence » en pixels réels."""
    return int(round(value * _scale))


# --- Maths & couleurs -------------------------------------------------------------
def clamp(v, lo=0.0, hi=1.0):
    return lo if v < lo else hi if v > hi else v


def lerp(a, b, t):
    return a + (b - a) * t


def lerp_color(c1, c2, t):
    t = clamp(t)
    return (int(c1[0] + (c2[0] - c1[0]) * t),
            int(c1[1] + (c2[1] - c1[1]) * t),
            int(c1[2] + (c2[2] - c1[2]) * t))


def lighten(color, amount):
    return lerp_color(color, (255, 255, 255), amount)


def darken(color, amount):
    return lerp_color(color, (0, 0, 0), amount)


def ease_out_cubic(t):
    t = clamp(t)
    return 1 - (1 - t) ** 3


def ease_in_out(t):
    t = clamp(t)
    return 3 * t * t - 2 * t * t * t


def ease_out_back(t):
    t = clamp(t)
    c1, c3 = 1.70158, 2.70158
    return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2


# --- Polices & texte ----------------------------------------------------------------
FONT_NAMES = "bahnschrift,segoeui,verdana,dejavusans,arial"
# Police de secours pour les symboles (flèches, étoiles) absents de la police principale.
SYMBOL_FONT_NAMES = "segoeuisymbol,seguisym,dejavusans,arial"
_fonts = {}
_text_cache = {}


def font(size, bold=False, symbols=False):
    key = (size, bold, symbols)
    if key not in _fonts:
        names = SYMBOL_FONT_NAMES if symbols else FONT_NAMES
        _fonts[key] = pygame.font.SysFont(names, max(8, size), bold=bold and not symbols)
    return _fonts[key]


def _is_symbol(ch):
    return ord(ch) >= 0x2190


def render_text(text, size, color, bold=False):
    key = (text, size, color, bold)
    surf = _text_cache.get(key)
    if surf is None:
        if len(_text_cache) > 800:
            _text_cache.clear()
        if not any(_is_symbol(ch) for ch in text):
            surf = font(size, bold).render(text, True, color)
        else:
            # Découpe en segments « texte » / « symboles » rendus chacun avec sa police.
            runs, current, sym = [], "", None
            for ch in text:
                if sym is not None and _is_symbol(ch) != sym:
                    runs.append((current, sym))
                    current = ""
                current += ch
                sym = _is_symbol(ch)
            runs.append((current, sym))
            parts = [font(size, bold, s).render(t, True, color) for t, s in runs]
            height = max(p.get_height() for p in parts)
            surf = pygame.Surface((sum(p.get_width() for p in parts), height), pygame.SRCALPHA)
            x = 0
            for p in parts:
                surf.blit(p, (x, (height - p.get_height()) // 2))
                x += p.get_width()
        _text_cache[key] = surf
    return surf


def draw_text(surf, text, size, color, pos, anchor="center", bold=False,
              shadow=True, alpha=255):
    """Dessine un texte (taille déjà en pixels) et renvoie son rectangle."""
    img = render_text(text, size, color, bold)
    rect = img.get_rect(**{anchor: (int(pos[0]), int(pos[1]))})
    if shadow:
        sh = render_text(text, size, (0, 0, 0), bold)
        sh.set_alpha(int(110 * alpha / 255))
        off = max(1, size // 18)
        surf.blit(sh, rect.move(off, off))
    img.set_alpha(alpha)
    surf.blit(img, rect)
    return rect


# --- Surfaces utilitaires -------------------------------------------------------------
def vertical_gradient(size, top, bottom):
    tiny = pygame.Surface((2, 2))
    tiny.fill(top)
    tiny.set_at((0, 1), bottom)
    tiny.set_at((1, 1), bottom)
    return pygame.transform.smoothscale(tiny, size)


_glow_cache = {}


def glow(radius, color):
    """Halo radial à blitter avec BLEND_ADD (rendu « néon »)."""
    radius = max(2, int(radius))
    key = (radius, color)
    surf = _glow_cache.get(key)
    if surf is None:
        if len(_glow_cache) > 400:
            _glow_cache.clear()
        surf = pygame.Surface((radius * 2, radius * 2))
        step = max(1, radius // 24)
        for r in range(radius, 0, -step):
            k = (1 - r / radius) ** 2
            pygame.draw.circle(surf, (int(color[0] * k), int(color[1] * k), int(color[2] * k)),
                               (radius, radius), r)
        _glow_cache[key] = surf
    return surf


def blit_glow(surf, center, radius, color):
    g = glow(radius, color)
    surf.blit(g, (center[0] - g.get_width() // 2, center[1] - g.get_height() // 2),
              special_flags=pygame.BLEND_ADD)


def draw_panel(surf, rect, color, alpha=230, radius=None, border=None, border_width=2):
    """Rectangle arrondi semi-transparent."""
    radius = S(16) if radius is None else radius
    panel = pygame.Surface(rect.size, pygame.SRCALPHA)
    pygame.draw.rect(panel, (*color, alpha), panel.get_rect(), border_radius=radius)
    if border:
        pygame.draw.rect(panel, border, panel.get_rect(), max(1, border_width), border_radius=radius)
    surf.blit(panel, rect.topleft)


def dim_screen(surf, alpha=150, color=(0, 0, 0)):
    veil = pygame.Surface(surf.get_size(), pygame.SRCALPHA)
    veil.fill((*color, alpha))
    surf.blit(veil, (0, 0))


# --- Formes ----------------------------------------------------------------------------
def draw_heart(surf, center, size, color):
    cx, cy = center
    r = size * 0.28
    pygame.draw.circle(surf, color, (cx - size * 0.24, cy - size * 0.08), r)
    pygame.draw.circle(surf, color, (cx + size * 0.24, cy - size * 0.08), r)
    pygame.draw.polygon(surf, color, [(cx - size * 0.5, cy), (cx + size * 0.5, cy),
                                      (cx, cy + size * 0.48)])


def star_points(center, radius, inner=0.45):
    pts = []
    for i in range(10):
        a = -math.pi / 2 + i * math.pi / 5
        r = radius if i % 2 == 0 else radius * inner
        pts.append((center[0] + math.cos(a) * r, center[1] + math.sin(a) * r))
    return pts


def draw_star(surf, center, radius, color, outline=None):
    pts = star_points(center, radius)
    pygame.draw.polygon(surf, color, pts)
    if outline:
        pygame.draw.polygon(surf, outline, pts, max(1, int(radius / 7)))


def draw_padlock(surf, center, size, color):
    cx, cy = center
    w, h = size * 0.7, size * 0.5
    body = pygame.Rect(0, 0, w, h)
    body.midtop = (cx, cy - size * 0.05)
    arc = pygame.Rect(0, 0, w * 0.7, size * 0.7)
    arc.midtop = (cx, cy - size * 0.42)
    pygame.draw.arc(surf, color, arc, 0, math.pi, max(2, int(size * 0.1)))
    pygame.draw.rect(surf, color, body, border_radius=max(2, int(size * 0.08)))


def draw_apple(surf, center, radius, color, leaf=(90, 210, 90)):
    cx, cy = center
    pygame.draw.circle(surf, darken(color, 0.25), (cx, cy), radius)
    pygame.draw.circle(surf, color, (cx - radius * 0.08, cy - radius * 0.1), radius * 0.88)
    pygame.draw.circle(surf, lighten(color, 0.55), (cx - radius * 0.38, cy - radius * 0.38),
                       max(1, radius * 0.2))
    pygame.draw.line(surf, (110, 70, 40), (cx, cy - radius * 0.8), (cx + radius * 0.15, cy - radius * 1.25),
                     max(2, int(radius * 0.16)))
    # Feuille : ellipse inclinée approximée par un polygone
    lx, ly, ang = cx + radius * 0.45, cy - radius * 1.05, -0.5
    pts = []
    for i in range(12):
        t = i / 12 * math.tau
        ex, ey = math.cos(t) * radius * 0.42, math.sin(t) * radius * 0.2
        pts.append((lx + ex * math.cos(ang) - ey * math.sin(ang), ly + ex * math.sin(ang) + ey * math.cos(ang)))
    pygame.draw.polygon(surf, leaf, pts)


def draw_powerup_icon(surf, kind, center, size, color, t=0.0):
    """Badge arrondi + pictogramme d'un bonus."""
    cx, cy = int(center[0]), int(center[1])
    rect = pygame.Rect(0, 0, int(size), int(size))
    rect.center = (cx, cy)
    pygame.draw.rect(surf, darken(color, 0.55), rect, border_radius=max(3, int(size * 0.28)))
    pygame.draw.rect(surf, color, rect, max(2, int(size * 0.08)), border_radius=max(3, int(size * 0.28)))
    white = (250, 250, 255)
    lw = max(2, int(size * 0.08))
    if kind == "slow":
        r = size * 0.27
        pygame.draw.circle(surf, white, (cx, cy), r, lw)
        a = t * 2.0
        pygame.draw.line(surf, white, (cx, cy), (cx, cy - r * 0.7), lw)
        pygame.draw.line(surf, white, (cx, cy), (cx + math.cos(a) * r * 0.6, cy + math.sin(a) * r * 0.6), lw)
    elif kind == "ghost":
        r = size * 0.22
        top = cy - size * 0.06
        pygame.draw.circle(surf, white, (cx, top), r)
        pygame.draw.rect(surf, white, (cx - r, top, r * 2, size * 0.24))
        for i in range(3):
            pygame.draw.circle(surf, white, (cx - r + r / 3 + i * r * 2 / 3, top + size * 0.24), r / 3)
        dark = darken(color, 0.6)
        pygame.draw.circle(surf, dark, (cx - r * 0.4, top), max(1, r * 0.22))
        pygame.draw.circle(surf, dark, (cx + r * 0.4, top), max(1, r * 0.22))
    elif kind == "shrink":
        s = size * 0.2
        pygame.draw.polygon(surf, white, [(cx - s * 1.6, cy - s), (cx - s * 0.3, cy), (cx - s * 1.6, cy + s)])
        pygame.draw.polygon(surf, white, [(cx + s * 1.6, cy - s), (cx + s * 0.3, cy), (cx + s * 1.6, cy + s)])
    elif kind == "double":
        draw_text(surf, "x2", max(8, int(size * 0.5)), white, (cx, cy), bold=True, shadow=False)


def make_icon():
    """Icône de fenêtre dessinée par le code (pas de fichier externe)."""
    icon = pygame.Surface((64, 64), pygame.SRCALPHA)
    pygame.draw.rect(icon, (20, 16, 42), icon.get_rect(), border_radius=14)
    pts = [(14, 46), (22, 46), (30, 46), (30, 38), (30, 30), (38, 30), (46, 30), (46, 22)]
    for i, p in enumerate(pts):
        col = lerp_color((150, 70, 255), (0, 255, 200), i / (len(pts) - 1))
        pygame.draw.circle(icon, col, p, 6)
    pygame.draw.circle(icon, (255, 70, 110), (46, 12), 5)
    return icon


# --- Boutons & menus ------------------------------------------------------------------------
class Button:
    def __init__(self, label, action, enabled=True, sub=None):
        self.label = label
        self.action = action
        self.enabled = enabled
        self.sub = sub
        self.rect = pygame.Rect(0, 0, 0, 0)
        self.hover = 0.0


class Menu:
    """Liste verticale de boutons pilotable au clavier et à la souris."""

    UP_KEYS = (pygame.K_UP, pygame.K_z, pygame.K_w)
    DOWN_KEYS = (pygame.K_DOWN, pygame.K_s)
    OK_KEYS = (pygame.K_RETURN, pygame.K_KP_ENTER, pygame.K_SPACE)

    def __init__(self, app, buttons, width=380, height=56, gap=12):
        self.app = app
        self.buttons = buttons
        self.width, self.height, self.gap = width, height, gap
        self.selected = next((i for i, b in enumerate(buttons) if b.enabled), 0)
        self.age = 0.0

    def total_height(self):
        n = len(self.buttons)
        return n * S(self.height) + (n - 1) * S(self.gap)

    def layout(self, cx, top):
        w, h, g = S(self.width), S(self.height), S(self.gap)
        for i, b in enumerate(self.buttons):
            b.rect = pygame.Rect(0, 0, w, h)
            b.rect.midtop = (cx, top + i * (h + g))

    def move(self, step):
        n = len(self.buttons)
        i = self.selected
        for _ in range(n):
            i = (i + step) % n
            if self.buttons[i].enabled:
                break
        if i != self.selected:
            self.selected = i
            self.app.audio.play("hover")

    def activate(self):
        button = self.buttons[self.selected]
        if button.enabled:
            self.app.audio.play("click")
            button.action()

    def handle_event(self, e):
        if e.type == pygame.KEYDOWN:
            if e.key in self.UP_KEYS:
                self.move(-1)
            elif e.key in self.DOWN_KEYS:
                self.move(1)
            elif e.key in self.OK_KEYS:
                self.activate()
                return True
        elif e.type == pygame.MOUSEMOTION:
            for i, b in enumerate(self.buttons):
                if b.enabled and b.rect.collidepoint(e.pos) and i != self.selected:
                    self.selected = i
                    self.app.audio.play("hover")
        elif e.type == pygame.MOUSEBUTTONDOWN and e.button == 1:
            for i, b in enumerate(self.buttons):
                if b.enabled and b.rect.collidepoint(e.pos):
                    self.selected = i
                    self.activate()
                    return True
        return False

    def update(self, dt):
        self.age += dt
        for i, b in enumerate(self.buttons):
            target = 1.0 if i == self.selected else 0.0
            b.hover += (target - b.hover) * min(1.0, dt * 14)

    def draw(self, surf, theme):
        for i, b in enumerate(self.buttons):
            appear = ease_out_cubic((self.age - i * 0.06) / 0.45)
            if appear <= 0:
                continue
            rect = b.rect.inflate(int(S(14) * b.hover), int(S(4) * b.hover))
            rect.x += int((1 - appear) * -S(90))
            draw_button(surf, rect, b, theme, int(255 * appear))


def draw_button(surf, rect, button, theme, alpha=255):
    pad = S(14)
    layer = pygame.Surface((rect.w + pad * 2, rect.h + pad * 2), pygame.SRCALPHA)
    inner = pygame.Rect(pad, pad, rect.w, rect.h)
    radius = S(14)
    h = button.hover if button.enabled else 0.0
    accent = theme["accent"]
    if h > 0.02:
        for k in range(3):
            g = inner.inflate(S(4) * (k + 1) * 2, S(4) * (k + 1) * 2)
            pygame.draw.rect(layer, (*accent, int(28 * h / (k + 1))), g, border_radius=radius + S(4) * (k + 1))
    fill = lerp_color(theme["panel"], darken(accent, 0.45), h)
    pygame.draw.rect(layer, (*fill, 235), inner, border_radius=radius)
    border = lerp_color(darken(accent, 0.5), accent, h)
    pygame.draw.rect(layer, (*border, 255), inner, max(1, S(2)), border_radius=radius)
    if button.enabled:
        color = lerp_color(theme["text_dim"], theme["text"], 0.45 + 0.55 * h)
    else:
        color = darken(theme["text_dim"], 0.45)
    if h > 0.05:
        s = S(7)
        x = inner.x + S(18) - int((1 - h) * S(10))
        cy = inner.centery
        pygame.draw.polygon(layer, (*accent, int(255 * h)), [(x, cy - s), (x + s, cy), (x, cy + s)])
    size = S(24)
    if button.sub:
        draw_text(layer, button.label, size, color, (inner.centerx, inner.centery - S(8)), bold=True)
        draw_text(layer, button.sub, S(15), theme["text_dim"], (inner.centerx, inner.centery + S(14)),
                  shadow=False)
    else:
        draw_text(layer, button.label, size, color, inner.center, bold=True)
    layer.set_alpha(alpha)
    surf.blit(layer, (rect.x - pad, rect.y - pad))


class TextInput:
    """Champ de saisie simple (nom du joueur)."""

    def __init__(self, text="", max_len=14):
        self.text = text
        self.max_len = max_len
        self.fresh = True   # la première frappe remplace le texte proposé

    def handle_event(self, e):
        if e.type == pygame.TEXTINPUT:
            if self.fresh:
                self.text = ""
                self.fresh = False
            for ch in e.text:
                if ch.isprintable() and len(self.text) < self.max_len:
                    self.text += ch
        elif e.type == pygame.KEYDOWN:
            if e.key == pygame.K_BACKSPACE:
                self.fresh = False
                self.text = self.text[:-1]
            elif e.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                return "submit"
        return None

    def draw(self, surf, rect, theme, time):
        draw_panel(surf, rect, darken(theme["panel"], 0.3), 240, S(12), theme["accent"], S(2))
        img = render_text(self.text, S(28), theme["text_dim"] if self.fresh else theme["text"], True)
        x = rect.centerx - img.get_width() // 2
        surf.blit(img, (x, rect.centery - img.get_height() // 2))
        if int(time * 2.2) % 2 == 0:
            cx = x + img.get_width() + S(4)
            pygame.draw.line(surf, theme["accent"], (cx, rect.centery - S(15)), (cx, rect.centery + S(15)), S(3))

"""Persistance locale SQLite : paramètres, scores, historique, progression et sauvegarde."""
import json
import sqlite3
from datetime import datetime

SCHEMA = """
CREATE TABLE IF NOT EXISTS settings (
    key   TEXT PRIMARY KEY,
    value TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS scores (
    id          INTEGER PRIMARY KEY AUTOINCREMENT,
    player      TEXT    NOT NULL,
    mode        TEXT    NOT NULL,
    score       INTEGER NOT NULL,
    level       INTEGER NOT NULL,
    apples      INTEGER NOT NULL,
    length      INTEGER NOT NULL,
    max_combo   INTEGER NOT NULL,
    duration    REAL    NOT NULL,
    difficulty  TEXT    NOT NULL,
    victory     INTEGER NOT NULL DEFAULT 0,
    played_at   TEXT    NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_scores_mode_score ON scores (mode, score DESC);

CREATE TABLE IF NOT EXISTS level_progress (
    level        INTEGER PRIMARY KEY,
    best_score   INTEGER NOT NULL DEFAULT 0,
    stars        INTEGER NOT NULL DEFAULT 0,
    completed_at TEXT
);

CREATE TABLE IF NOT EXISTS saved_game (
    slot     INTEGER PRIMARY KEY CHECK (slot = 1),
    data     TEXT NOT NULL,
    saved_at TEXT NOT NULL
);
"""


def _now():
    return datetime.now().isoformat(timespec="seconds")


class Database:
    def __init__(self, path):
        path.parent.mkdir(parents=True, exist_ok=True)
        self.conn = sqlite3.connect(path)
        self.conn.row_factory = sqlite3.Row
        self.conn.executescript(SCHEMA)
        self.conn.commit()

    def close(self):
        self.conn.close()

    # --- Paramètres --------------------------------------------------------
    def load_settings(self, defaults):
        settings = dict(defaults)
        for row in self.conn.execute("SELECT key, value FROM settings"):
            if row["key"] in defaults:
                try:
                    settings[row["key"]] = json.loads(row["value"])
                except json.JSONDecodeError:
                    pass
        return settings

    def save_setting(self, key, value):
        self.conn.execute(
            "INSERT INTO settings (key, value) VALUES (?, ?) "
            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
            (key, json.dumps(value)))
        self.conn.commit()

    # --- Scores & historique ------------------------------------------------------
    def add_score(self, player, result):
        cur = self.conn.execute(
            "INSERT INTO scores (player, mode, score, level, apples, length, max_combo, duration,"
            " difficulty, victory, played_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
            (player, result["mode"], result["score"], result["level"], result["apples"],
             result["length"], result["max_combo"], result["duration"], result["difficulty"],
             int(result["victory"]), _now()))
        self.conn.commit()
        return cur.lastrowid

    def top_scores(self, mode, limit=10):
        return self.conn.execute(
            "SELECT * FROM scores WHERE mode = ? ORDER BY score DESC, played_at ASC LIMIT ?",
            (mode, limit)).fetchall()

    def recent_games(self, limit=10):
        return self.conn.execute(
            "SELECT * FROM scores ORDER BY played_at DESC, id DESC LIMIT ?", (limit,)).fetchall()

    def best_score(self, mode):
        row = self.conn.execute("SELECT MAX(score) AS best FROM scores WHERE mode = ?", (mode,)).fetchone()
        return row["best"] or 0

    def rank_of(self, mode, score):
        """Rang qu'obtiendrait ce score dans le classement du mode (1 = meilleur)."""
        row = self.conn.execute("SELECT COUNT(*) AS n FROM scores WHERE mode = ? AND score > ?",
                                (mode, score)).fetchone()
        return row["n"] + 1

    def stats(self):
        row = self.conn.execute(
            "SELECT COUNT(*) AS games, COALESCE(SUM(apples), 0) AS apples,"
            " COALESCE(SUM(duration), 0) AS duration, COALESCE(MAX(score), 0) AS best,"
            " COALESCE(MAX(length), 0) AS longest, COALESCE(MAX(max_combo), 0) AS combo,"
            " COALESCE(AVG(score), 0) AS average, COALESCE(SUM(victory), 0) AS victories"
            " FROM scores").fetchone()
        levels = self.conn.execute(
            "SELECT COUNT(*) AS done, COALESCE(SUM(stars), 0) AS stars FROM level_progress").fetchone()
        stats = dict(row)
        stats["levels_done"] = levels["done"]
        stats["stars"] = levels["stars"]
        return stats

    # --- Progression du mode Aventure -------------------------------------------------
    def level_progress(self):
        return {row["level"]: {"best": row["best_score"], "stars": row["stars"]}
                for row in self.conn.execute("SELECT * FROM level_progress")}

    def unlocked_level(self, max_level):
        row = self.conn.execute("SELECT MAX(level) AS last FROM level_progress").fetchone()
        return min(max_level, (row["last"] or 0) + 1)

    def complete_level(self, level, score, stars):
        self.conn.execute(
            "INSERT INTO level_progress (level, best_score, stars, completed_at) VALUES (?, ?, ?, ?) "
            "ON CONFLICT(level) DO UPDATE SET best_score = MAX(best_score, excluded.best_score),"
            " stars = MAX(stars, excluded.stars), completed_at = excluded.completed_at",
            (level, score, stars, _now()))
        self.conn.commit()

    # --- Sauvegarde « Continuer » ---------------------------------------------------------
    def save_game(self, state):
        self.conn.execute(
            "INSERT INTO saved_game (slot, data, saved_at) VALUES (1, ?, ?) "
            "ON CONFLICT(slot) DO UPDATE SET data = excluded.data, saved_at = excluded.saved_at",
            (json.dumps(state), _now()))
        self.conn.commit()

    def load_game(self):
        row = self.conn.execute("SELECT data FROM saved_game WHERE slot = 1").fetchone()
        if row is None:
            return None
        try:
            return json.loads(row["data"])
        except json.JSONDecodeError:
            return None

    def delete_save(self):
        self.conn.execute("DELETE FROM saved_game")
        self.conn.commit()

    def reset_all(self):
        self.conn.executescript("DELETE FROM scores; DELETE FROM level_progress; DELETE FROM saved_game;")
        self.conn.commit()

"""Persistance locale SQLite : paramètres, scores, historique, progression et sauvegarde."""
import json
import sqlite3
from datetime import datetime

SCHEMA = """
CREATE TABLE IF NOT EXISTS settings (
    key   TEXT PRIMARY KEY,
    value TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS scores (
    id          INTEGER PRIMARY KEY AUTOINCREMENT,
    player      TEXT    NOT NULL,
    mode        TEXT    NOT NULL,
    score       INTEGER NOT NULL,
    level       INTEGER NOT NULL,
    apples      INTEGER NOT NULL,
    length      INTEGER NOT NULL,
    max_combo   INTEGER NOT NULL,
    duration    REAL    NOT NULL,
    difficulty  TEXT    NOT NULL,
    victory     INTEGER NOT NULL DEFAULT 0,
    played_at   TEXT    NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_scores_mode_score ON scores (mode, score DESC);

CREATE TABLE IF NOT EXISTS level_progress (
    level        INTEGER PRIMARY KEY,
    best_score   INTEGER NOT NULL DEFAULT 0,
    stars        INTEGER NOT NULL DEFAULT 0,
    completed_at TEXT
);

CREATE TABLE IF NOT EXISTS saved_game (
    slot     INTEGER PRIMARY KEY CHECK (slot = 1),
    data     TEXT NOT NULL,
    saved_at TEXT NOT NULL
);
"""


def _now():
    return datetime.now().isoformat(timespec="seconds")


class Database:
    def __init__(self, path):
        path.parent.mkdir(parents=True, exist_ok=True)
        self.conn = sqlite3.connect(path)
        self.conn.row_factory = sqlite3.Row
        self.conn.executescript(SCHEMA)
        self.conn.commit()

    def close(self):
        self.conn.close()

    # --- Paramètres --------------------------------------------------------
    def load_settings(self, defaults):
        settings = dict(defaults)
        for row in self.conn.execute("SELECT key, value FROM settings"):
            if row["key"] in defaults:
                try:
                    settings[row["key"]] = json.loads(row["value"])
                except json.JSONDecodeError:
                    pass
        return settings

    def save_setting(self, key, value):
        self.conn.execute(
            "INSERT INTO settings (key, value) VALUES (?, ?) "
            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
            (key, json.dumps(value)))
        self.conn.commit()

    # --- Scores & historique ------------------------------------------------------
    def add_score(self, player, result):
        cur = self.conn.execute(
            "INSERT INTO scores (player, mode, score, level, apples, length, max_combo, duration,"
            " difficulty, victory, played_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
            (player, result["mode"], result["score"], result["level"], result["apples"],
             result["length"], result["max_combo"], result["duration"], result["difficulty"],
             int(result["victory"]), _now()))
        self.conn.commit()
        return cur.lastrowid

    def top_scores(self, mode, limit=10):
        return self.conn.execute(
            "SELECT * FROM scores WHERE mode = ? ORDER BY score DESC, played_at ASC LIMIT ?",
            (mode, limit)).fetchall()

    def recent_games(self, limit=10):
        return self.conn.execute(
            "SELECT * FROM scores ORDER BY played_at DESC, id DESC LIMIT ?", (limit,)).fetchall()

    def best_score(self, mode):
        row = self.conn.execute("SELECT MAX(score) AS best FROM scores WHERE mode = ?", (mode,)).fetchone()
        return row["best"] or 0

    def rank_of(self, mode, score):
        """Rang qu'obtiendrait ce score dans le classement du mode (1 = meilleur)."""
        row = self.conn.execute("SELECT COUNT(*) AS n FROM scores WHERE mode = ? AND score > ?",
                                (mode, score)).fetchone()
        return row["n"] + 1

    def stats(self):
        row = self.conn.execute(
            "SELECT COUNT(*) AS games, COALESCE(SUM(apples), 0) AS apples,"
            " COALESCE(SUM(duration), 0) AS duration, COALESCE(MAX(score), 0) AS best,"
            " COALESCE(MAX(length), 0) AS longest, COALESCE(MAX(max_combo), 0) AS combo,"
            " COALESCE(AVG(score), 0) AS average, COALESCE(SUM(victory), 0) AS victories"
            " FROM scores").fetchone()
        levels = self.conn.execute(
            "SELECT COUNT(*) AS done, COALESCE(SUM(stars), 0) AS stars FROM level_progress").fetchone()
        stats = dict(row)
        stats["levels_done"] = levels["done"]
        stats["stars"] = levels["stars"]
        return stats

    # --- Progression du mode Aventure -------------------------------------------------
    def level_progress(self):
        return {row["level"]: {"best": row["best_score"], "stars": row["stars"]}
                for row in self.conn.execute("SELECT * FROM level_progress")}

    def unlocked_level(self, max_level):
        row = self.conn.execute("SELECT MAX(level) AS last FROM level_progress").fetchone()
        return min(max_level, (row["last"] or 0) + 1)

    def complete_level(self, level, score, stars):
        self.conn.execute(
            "INSERT INTO level_progress (level, best_score, stars, completed_at) VALUES (?, ?, ?, ?) "
            "ON CONFLICT(level) DO UPDATE SET best_score = MAX(best_score, excluded.best_score),"
            " stars = MAX(stars, excluded.stars), completed_at = excluded.completed_at",
            (level, score, stars, _now()))
        self.conn.commit()

    # --- Sauvegarde « Continuer » ---------------------------------------------------------
    def save_game(self, state):
        self.conn.execute(
            "INSERT INTO saved_game (slot, data, saved_at) VALUES (1, ?, ?) "
            "ON CONFLICT(slot) DO UPDATE SET data = excluded.data, saved_at = excluded.saved_at",
            (json.dumps(state), _now()))
        self.conn.commit()

    def load_game(self):
        row = self.conn.execute("SELECT data FROM saved_game WHERE slot = 1").fetchone()
        if row is None:
            return None
        try:
            return json.loads(row["data"])
        except json.JSONDecodeError:
            return None

    def delete_save(self):
        self.conn.execute("DELETE FROM saved_game")
        self.conn.commit()

    def reset_all(self):
        self.conn.executescript("DELETE FROM scores; DELETE FROM level_progress; DELETE FROM saved_game;")
        self.conn.commit()

"""Sons et musique générés par synthèse : aucun fichier audio externe n'est nécessaire."""
import io
import math
import random
import threading
import wave
from array import array

import pygame

from .config import DATA_DIR

RATE = 22050
MUSIC_FILE = DATA_DIR / "music_v1.wav"


def midi(note):
    return 440.0 * 2 ** ((note - 69) / 12)


def tone(freq, dur, wave_type="square", vol=0.4, freq_end=None, attack=0.004, release=0.05, duty=0.5):
    """Génère une note (liste de flottants entre -1 et 1)."""
    n = max(1, int(RATE * dur))
    out = [0.0] * n
    phase = 0.0
    df = (freq_end - freq) if freq_end else 0.0
    att = max(1, int(attack * RATE))
    rel = max(1, int(release * RATE))
    sin, tau, rnd = math.sin, math.tau, random.random
    for i in range(n):
        phase = (phase + (freq + df * i / n) / RATE) % 1.0
        if wave_type == "sine":
            v = sin(tau * phase)
        elif wave_type == "square":
            v = 1.0 if phase < duty else -1.0
        elif wave_type == "tri":
            v = 4.0 * abs(phase - 0.5) - 1.0
        elif wave_type == "saw":
            v = 2.0 * phase - 1.0
        else:
            v = rnd() * 2.0 - 1.0
        env = i / att if i < att else 1.0
        if n - i < rel:
            env *= (n - i) / rel
        out[i] = v * vol * env
    return out


def mix_into(base, part, start=0.0):
    """Ajoute `part` dans `base` à partir de `start` secondes."""
    offset = int(start * RATE)
    end = offset + len(part)
    if end > len(base):
        base.extend([0.0] * (end - len(base)))
    for i, v in enumerate(part):
        base[offset + i] += v
    return base


def sequence(*parts):
    out = []
    for p in parts:
        out.extend(p)
    return out


def to_wav_bytes(samples, normalize=False):
    peak = max(1e-6, max(abs(v) for v in samples)) if normalize else 1.0
    gain = 0.9 / peak if normalize else 1.0
    data = array("h", (int(max(-1.0, min(1.0, v * gain)) * 32767) for v in samples))
    buf = io.BytesIO()
    with wave.open(buf, "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(RATE)
        w.writeframes(data.tobytes())
    return buf.getvalue()


def build_sound_bank():
    s = {}
    for i, k in enumerate((1.0, 1.12, 1.26, 1.34, 1.5)):
        s[f"eat{i}"] = mix_into(tone(520 * k, 0.09, "square", 0.22, 900 * k, duty=0.25),
                                tone(1040 * k, 0.07, "sine", 0.18))
    s["golden"] = sequence(*(tone(midi(n), 0.07, "square", 0.2, duty=0.25, release=0.03)
                             for n in (72, 76, 79, 84, 88)))
    s["power"] = mix_into(tone(300, 0.3, "tri", 0.4, 1300), tone(1800, 0.25, "sine", 0.1, 2600), 0.05)
    s["die"] = mix_into(tone(420, 0.55, "saw", 0.3, 50, release=0.2), tone(0, 0.45, "noise", 0.25, release=0.3))
    s["level"] = sequence(tone(midi(67), 0.11, "square", 0.22, duty=0.3), tone(midi(72), 0.11, "square", 0.22, duty=0.3),
                          tone(midi(76), 0.11, "square", 0.22, duty=0.3),
                          mix_into(tone(midi(79), 0.45, "square", 0.2, duty=0.3, release=0.25),
                                   tone(midi(84), 0.45, "sine", 0.2, release=0.25)))
    s["gameover"] = sequence(*(tone(midi(n), d, "tri", 0.45, release=0.08)
                               for n, d in ((64, 0.22), (62, 0.22), (60, 0.22), (55, 0.6))))
    s["click"] = tone(880, 0.05, "tri", 0.45, 660)
    s["hover"] = tone(1300, 0.025, "sine", 0.2)
    s["count"] = tone(520, 0.14, "square", 0.18, duty=0.3)
    s["go"] = mix_into(tone(1040, 0.35, "square", 0.18, duty=0.3, release=0.2), tone(780, 0.35, "sine", 0.2))
    s["portal"] = sequence(tone(900, 0.1, "sine", 0.35, 300), tone(300, 0.12, "sine", 0.35, 1100))
    s["pause"] = sequence(tone(660, 0.07, "tri", 0.4), tone(440, 0.1, "tri", 0.4))
    s["star"] = tone(1568, 0.18, "sine", 0.3, 2093, release=0.12)
    return s


def build_music():
    """Petite boucle chiptune (La m - Fa - Do - Sol) d'environ 17 secondes."""
    beat = 60 / 110
    chords = [(57, 60, 64), (53, 57, 60), (48, 52, 55), (55, 59, 62)]
    pattern = (0, 1, 2, 1, 0, 2, 1, 2)
    out = []
    for rep in range(2):
        for bar, chord in enumerate(chords):
            t0 = (rep * 4 + bar) * 4 * beat
            root = chord[0] - 24 if chord[0] >= 55 else chord[0] - 12
            for b in range(4):
                note = root + (12 if b == 2 else 0)
                mix_into(out, tone(midi(note), beat * 0.85, "tri", 0.32, release=0.12), t0 + b * beat)
                if b in (0, 2):
                    mix_into(out, tone(130, 0.12, "sine", 0.45, 40, release=0.06), t0 + b * beat)
            for e in range(8):
                note = chord[pattern[e]] + 12 + (12 if rep == 1 and e % 4 == 3 else 0)
                start = t0 + e * beat / 2
                mix_into(out, tone(midi(note), beat * 0.45, "square", 0.07, duty=0.25, release=0.1), start)
                mix_into(out, tone(midi(note), beat * 0.45, "sine", 0.09, release=0.1), start)
                if e % 2 == 1:
                    mix_into(out, tone(0, 0.03, "noise", 0.06, release=0.02), start)
    total = int(8 * 4 * beat * RATE)
    return out[:total]


class Audio:
    def __init__(self, settings):
        self.enabled = pygame.mixer.get_init() is not None
        self.sounds = {}
        self.music = None
        self._music_ready = None
        self._music_started = False
        self.settings = settings
        if not self.enabled:
            return
        pygame.mixer.set_num_channels(24)
        pygame.mixer.set_reserved(1)
        self.music_channel = pygame.mixer.Channel(0)
        for name, samples in build_sound_bank().items():
            self.sounds[name] = pygame.mixer.Sound(io.BytesIO(to_wav_bytes(samples)))
        self.apply_volumes()

    def play(self, name):
        sound = self.sounds.get(name)
        if sound is not None:
            sound.play()

    def apply_volumes(self):
        if not self.enabled:
            return
        sfx = self.settings["sfx_volume"] / 10
        for sound in self.sounds.values():
            sound.set_volume(sfx)
        if self.music is not None:
            self.music.set_volume(self.settings["music_volume"] / 10 * 0.55)

    # La musique est générée (ou relue depuis le cache) dans un thread pour ne pas
    # bloquer le démarrage ; `update` la lance dès qu'elle est prête.
    def start_music(self):
        if not self.enabled or self._music_started:
            return
        self._music_started = True
        threading.Thread(target=self._load_music, daemon=True).start()

    def _load_music(self):
        try:
            if not MUSIC_FILE.exists():
                MUSIC_FILE.parent.mkdir(parents=True, exist_ok=True)
                MUSIC_FILE.write_bytes(to_wav_bytes(build_music(), normalize=True))
            self._music_ready = pygame.mixer.Sound(str(MUSIC_FILE))
        except (OSError, pygame.error):
            self._music_ready = None

    def update(self):
        if self._music_ready is not None and self.music is None:
            self.music = self._music_ready
            self.apply_volumes()
            self.music_channel.play(self.music, loops=-1, fade_ms=2000)

"""Sons et musique générés par synthèse : aucun fichier audio externe n'est nécessaire."""
import io
import math
import random
import threading
import wave
from array import array

import pygame

from .config import DATA_DIR

RATE = 22050
MUSIC_FILE = DATA_DIR / "music_v1.wav"


def midi(note):
    return 440.0 * 2 ** ((note - 69) / 12)


def tone(freq, dur, wave_type="square", vol=0.4, freq_end=None, attack=0.004, release=0.05, duty=0.5):
    """Génère une note (liste de flottants entre -1 et 1)."""
    n = max(1, int(RATE * dur))
    out = [0.0] * n
    phase = 0.0
    df = (freq_end - freq) if freq_end else 0.0
    att = max(1, int(attack * RATE))
    rel = max(1, int(release * RATE))
    sin, tau, rnd = math.sin, math.tau, random.random
    for i in range(n):
        phase = (phase + (freq + df * i / n) / RATE) % 1.0
        if wave_type == "sine":
            v = sin(tau * phase)
        elif wave_type == "square":
            v = 1.0 if phase < duty else -1.0
        elif wave_type == "tri":
            v = 4.0 * abs(phase - 0.5) - 1.0
        elif wave_type == "saw":
            v = 2.0 * phase - 1.0
        else:
            v = rnd() * 2.0 - 1.0
        env = i / att if i < att else 1.0
        if n - i < rel:
            env *= (n - i) / rel
        out[i] = v * vol * env
    return out


def mix_into(base, part, start=0.0):
    """Ajoute `part` dans `base` à partir de `start` secondes."""
    offset = int(start * RATE)
    end = offset + len(part)
    if end > len(base):
        base.extend([0.0] * (end - len(base)))
    for i, v in enumerate(part):
        base[offset + i] += v
    return base


def sequence(*parts):
    out = []
    for p in parts:
        out.extend(p)
    return out


def to_wav_bytes(samples, normalize=False):
    peak = max(1e-6, max(abs(v) for v in samples)) if normalize else 1.0
    gain = 0.9 / peak if normalize else 1.0
    data = array("h", (int(max(-1.0, min(1.0, v * gain)) * 32767) for v in samples))
    buf = io.BytesIO()
    with wave.open(buf, "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(RATE)
        w.writeframes(data.tobytes())
    return buf.getvalue()


def build_sound_bank():
    s = {}
    for i, k in enumerate((1.0, 1.12, 1.26, 1.34, 1.5)):
        s[f"eat{i}"] = mix_into(tone(520 * k, 0.09, "square", 0.22, 900 * k, duty=0.25),
                                tone(1040 * k, 0.07, "sine", 0.18))
    s["golden"] = sequence(*(tone(midi(n), 0.07, "square", 0.2, duty=0.25, release=0.03)
                             for n in (72, 76, 79, 84, 88)))
    s["power"] = mix_into(tone(300, 0.3, "tri", 0.4, 1300), tone(1800, 0.25, "sine", 0.1, 2600), 0.05)
    s["die"] = mix_into(tone(420, 0.55, "saw", 0.3, 50, release=0.2), tone(0, 0.45, "noise", 0.25, release=0.3))
    s["level"] = sequence(tone(midi(67), 0.11, "square", 0.22, duty=0.3), tone(midi(72), 0.11, "square", 0.22, duty=0.3),
                          tone(midi(76), 0.11, "square", 0.22, duty=0.3),
                          mix_into(tone(midi(79), 0.45, "square", 0.2, duty=0.3, release=0.25),
                                   tone(midi(84), 0.45, "sine", 0.2, release=0.25)))
    s["gameover"] = sequence(*(tone(midi(n), d, "tri", 0.45, release=0.08)
                               for n, d in ((64, 0.22), (62, 0.22), (60, 0.22), (55, 0.6))))
    s["click"] = tone(880, 0.05, "tri", 0.45, 660)
    s["hover"] = tone(1300, 0.025, "sine", 0.2)
    s["count"] = tone(520, 0.14, "square", 0.18, duty=0.3)
    s["go"] = mix_into(tone(1040, 0.35, "square", 0.18, duty=0.3, release=0.2), tone(780, 0.35, "sine", 0.2))
    s["portal"] = sequence(tone(900, 0.1, "sine", 0.35, 300), tone(300, 0.12, "sine", 0.35, 1100))
    s["pause"] = sequence(tone(660, 0.07, "tri", 0.4), tone(440, 0.1, "tri", 0.4))
    s["star"] = tone(1568, 0.18, "sine", 0.3, 2093, release=0.12)
    return s


def build_music():
    """Petite boucle chiptune (La m - Fa - Do - Sol) d'environ 17 secondes."""
    beat = 60 / 110
    chords = [(57, 60, 64), (53, 57, 60), (48, 52, 55), (55, 59, 62)]
    pattern = (0, 1, 2, 1, 0, 2, 1, 2)
    out = []
    for rep in range(2):
        for bar, chord in enumerate(chords):
            t0 = (rep * 4 + bar) * 4 * beat
            root = chord[0] - 24 if chord[0] >= 55 else chord[0] - 12
            for b in range(4):
                note = root + (12 if b == 2 else 0)
                mix_into(out, tone(midi(note), beat * 0.85, "tri", 0.32, release=0.12), t0 + b * beat)
                if b in (0, 2):
                    mix_into(out, tone(130, 0.12, "sine", 0.45, 40, release=0.06), t0 + b * beat)
            for e in range(8):
                note = chord[pattern[e]] + 12 + (12 if rep == 1 and e % 4 == 3 else 0)
                start = t0 + e * beat / 2
                mix_into(out, tone(midi(note), beat * 0.45, "square", 0.07, duty=0.25, release=0.1), start)
                mix_into(out, tone(midi(note), beat * 0.45, "sine", 0.09, release=0.1), start)
                if e % 2 == 1:
                    mix_into(out, tone(0, 0.03, "noise", 0.06, release=0.02), start)
    total = int(8 * 4 * beat * RATE)
    return out[:total]


class Audio:
    def __init__(self, settings):
        self.enabled = pygame.mixer.get_init() is not None
        self.sounds = {}
        self.music = None
        self._music_ready = None
        self._music_started = False
        self.settings = settings
        if not self.enabled:
            return
        pygame.mixer.set_num_channels(24)
        pygame.mixer.set_reserved(1)
        self.music_channel = pygame.mixer.Channel(0)
        for name, samples in build_sound_bank().items():
            self.sounds[name] = pygame.mixer.Sound(io.BytesIO(to_wav_bytes(samples)))
        self.apply_volumes()

    def play(self, name):
        sound = self.sounds.get(name)
        if sound is not None:
            sound.play()

    def apply_volumes(self):
        if not self.enabled:
            return
        sfx = self.settings["sfx_volume"] / 10
        for sound in self.sounds.values():
            sound.set_volume(sfx)
        if self.music is not None:
            self.music.set_volume(self.settings["music_volume"] / 10 * 0.55)

    # La musique est générée (ou relue depuis le cache) dans un thread pour ne pas
    # bloquer le démarrage ; `update` la lance dès qu'elle est prête.
    def start_music(self):
        if not self.enabled or self._music_started:
            return
        self._music_started = True
        threading.Thread(target=self._load_music, daemon=True).start()

    def _load_music(self):
        try:
            if not MUSIC_FILE.exists():
                MUSIC_FILE.parent.mkdir(parents=True, exist_ok=True)
                MUSIC_FILE.write_bytes(to_wav_bytes(build_music(), normalize=True))
            self._music_ready = pygame.mixer.Sound(str(MUSIC_FILE))
        except (OSError, pygame.error):
            self._music_ready = None

    def update(self):
        if self._music_ready is not None and self.music is None:
            self.music = self._music_ready
            self.apply_volumes()
            self.music_channel.play(self.music, loops=-1, fade_ms=2000)

"""Effets visuels : particules, textes flottants, tremblement, fond animé, transitions."""
import math
import random

import pygame

from . import ui
from .ui import S


class Particle:
    __slots__ = ("x", "y", "vx", "vy", "life", "max_life", "size", "color", "gravity", "drag", "glow")


class ParticleSystem:
    def __init__(self, limit=1500):
        self.items = []
        self.limit = limit

    def burst(self, x, y, color, count=16, speed=(60, 220), size=(2, 5), life=(0.4, 0.9),
              gravity=0.0, drag=2.5, glow=False, angle=None, spread=math.tau):
        for _ in range(count):
            if len(self.items) >= self.limit:
                return
            a = random.uniform(0, math.tau) if angle is None else angle + random.uniform(-spread / 2, spread / 2)
            sp = random.uniform(*speed)
            p = Particle()
            p.x, p.y = x, y
            p.vx, p.vy = math.cos(a) * sp, math.sin(a) * sp
            p.life = p.max_life = random.uniform(*life)
            p.size = random.uniform(*size)
            p.color = color
            p.gravity, p.drag, p.glow = gravity, drag, glow
            self.items.append(p)

    def update(self, dt):
        alive = []
        for p in self.items:
            p.life -= dt
            if p.life <= 0:
                continue
            k = max(0.0, 1 - p.drag * dt)
            p.vx *= k
            p.vy = p.vy * k + p.gravity * dt
            p.x += p.vx * dt
            p.y += p.vy * dt
            alive.append(p)
        self.items = alive

    def draw(self, surf, origin=(0, 0)):
        ox, oy = origin
        for p in self.items:
            k = p.life / p.max_life
            r = max(1.0, p.size * k)
            pos = (p.x + ox, p.y + oy)
            if p.glow:
                ui.blit_glow(surf, pos, r * 3.5, ui.darken(p.color, 0.5))
            pygame.draw.circle(surf, p.color, pos, r)

    def clear(self):
        self.items.clear()


class FloatingTexts:
    """Petits textes « +10 », « COMBO x3 » qui montent puis s'effacent."""

    def __init__(self):
        self.items = []

    def add(self, text, x, y, color, size=26, life=0.9):
        self.items.append({"text": text, "x": x, "y": y, "color": color, "size": size,
                           "life": life, "max": life})

    def update(self, dt):
        for t in self.items:
            t["life"] -= dt
            t["y"] -= S(55) * dt
        self.items = [t for t in self.items if t["life"] > 0]

    def draw(self, surf, origin=(0, 0)):
        for t in self.items:
            k = t["life"] / t["max"]
            pop = ui.ease_out_back(min(1.0, (1 - k) * 5))
            size = max(8, int(S(t["size"]) * (0.6 + 0.4 * pop)))
            ui.draw_text(surf, t["text"], size, t["color"], (t["x"] + origin[0], t["y"] + origin[1]),
                         bold=True, alpha=int(255 * min(1.0, k * 2)))


class ScreenShake:
    def __init__(self):
        self.power = 0.0

    def add(self, amount):
        self.power = min(30.0, self.power + amount)

    def update(self, dt):
        self.power *= math.exp(-7 * dt)
        if self.power < 0.3:
            self.power = 0.0

    def offset(self):
        if self.power <= 0:
            return 0, 0
        p = S(self.power)
        return random.randint(-p, p), random.randint(-p, p)


class Background:
    """Dégradé + vignette + orbes lumineuses qui dérivent lentement."""

    def __init__(self, count=14):
        self.key = None
        self.surface = None
        self.time = 0.0
        self.orbs = [{"x": random.random(), "y": random.random(), "r": random.uniform(60, 170),
                      "vx": random.uniform(-0.012, 0.012), "vy": random.uniform(-0.02, -0.004),
                      "phase": random.uniform(0, math.tau), "color": random.choice(("accent", "accent2", "snake_tail"))}
                     for _ in range(count)]

    def update(self, dt):
        self.time += dt
        for o in self.orbs:
            o["x"] = (o["x"] + o["vx"] * dt) % 1.0
            o["y"] = (o["y"] + o["vy"] * dt) % 1.0

    def _build(self, size, theme):
        surf = ui.vertical_gradient(size, theme["bg_top"], theme["bg_bottom"])
        # Vignette calculée en petit puis agrandie (rapide et doux)
        small = pygame.Surface((64, 36), pygame.SRCALPHA)
        for y in range(36):
            for x in range(64):
                d = math.hypot((x - 31.5) / 32, (y - 17.5) / 18)
                small.set_at((x, y), (0, 0, 0, int(200 * ui.clamp(d - 0.45) ** 1.5)))
        surf.blit(pygame.transform.smoothscale(small, size), (0, 0))
        return surf

    def draw(self, surf, theme):
        size = surf.get_size()
        key = (size, theme["name"])
        if key != self.key:
            self.key = key
            self.surface = self._build(size, theme)
        surf.blit(self.surface, (0, 0))
        w, h = size
        for o in self.orbs:
            pulse = 0.65 + 0.35 * math.sin(self.time * 0.8 + o["phase"])
            color = ui.darken(theme[o["color"]], 0.86 - 0.06 * pulse)
            ui.blit_glow(surf, (o["x"] * w, o["y"] * h), S(o["r"]), color)


class Transition:
    """Rideau de carrés en diagonale : ferme l'écran, exécute le callback, puis rouvre."""

    HALF = 0.42

    def __init__(self, callback):
        self.callback = callback
        self.phase = "out"
        self.t = 0.0
        self.done = False

    def update(self, dt):
        self.t += dt / self.HALF
        if self.t >= 1.0:
            if self.phase == "out":
                self.callback()
                self.phase = "in"
                self.t = 0.0
            else:
                self.done = True

    def draw(self, surf, theme):
        w, h = surf.get_size()
        tile = max(16, S(46))
        cols, rows = w // tile + 1, h // tile + 1
        span = cols + rows
        for j in range(rows):
            for i in range(cols):
                delay = (i + j) / span * 0.5
                local = ui.clamp((self.t - delay) / 0.5)
                cover = ui.ease_in_out(local) if self.phase == "out" else 1 - ui.ease_in_out(local)
                if cover <= 0.01:
                    continue
                size = int(tile * cover) + 2
                color = ui.lerp_color(theme["accent"], theme["bg_top"], 0.35 + 0.65 * cover)
                rect = pygame.Rect(0, 0, size, size)
                rect.center = (i * tile + tile // 2, j * tile + tile // 2)
                pygame.draw.rect(surf, color, rect, border_radius=int(tile * 0.3 * (1 - cover)))

"""Effets visuels : particules, textes flottants, tremblement, fond animé, transitions."""
import math
import random

import pygame

from . import ui
from .ui import S


class Particle:
    __slots__ = ("x", "y", "vx", "vy", "life", "max_life", "size", "color", "gravity", "drag", "glow")


class ParticleSystem:
    def __init__(self, limit=1500):
        self.items = []
        self.limit = limit

    def burst(self, x, y, color, count=16, speed=(60, 220), size=(2, 5), life=(0.4, 0.9),
              gravity=0.0, drag=2.5, glow=False, angle=None, spread=math.tau):
        for _ in range(count):
            if len(self.items) >= self.limit:
                return
            a = random.uniform(0, math.tau) if angle is None else angle + random.uniform(-spread / 2, spread / 2)
            sp = random.uniform(*speed)
            p = Particle()
            p.x, p.y = x, y
            p.vx, p.vy = math.cos(a) * sp, math.sin(a) * sp
            p.life = p.max_life = random.uniform(*life)
            p.size = random.uniform(*size)
            p.color = color
            p.gravity, p.drag, p.glow = gravity, drag, glow
            self.items.append(p)

    def update(self, dt):
        alive = []
        for p in self.items:
            p.life -= dt
            if p.life <= 0:
                continue
            k = max(0.0, 1 - p.drag * dt)
            p.vx *= k
            p.vy = p.vy * k + p.gravity * dt
            p.x += p.vx * dt
            p.y += p.vy * dt
            alive.append(p)
        self.items = alive

    def draw(self, surf, origin=(0, 0)):
        ox, oy = origin
        for p in self.items:
            k = p.life / p.max_life
            r = max(1.0, p.size * k)
            pos = (p.x + ox, p.y + oy)
            if p.glow:
                ui.blit_glow(surf, pos, r * 3.5, ui.darken(p.color, 0.5))
            pygame.draw.circle(surf, p.color, pos, r)

    def clear(self):
        self.items.clear()


class FloatingTexts:
    """Petits textes « +10 », « COMBO x3 » qui montent puis s'effacent."""

    def __init__(self):
        self.items = []

    def add(self, text, x, y, color, size=26, life=0.9):
        self.items.append({"text": text, "x": x, "y": y, "color": color, "size": size,
                           "life": life, "max": life})

    def update(self, dt):
        for t in self.items:
            t["life"] -= dt
            t["y"] -= S(55) * dt
        self.items = [t for t in self.items if t["life"] > 0]

    def draw(self, surf, origin=(0, 0)):
        for t in self.items:
            k = t["life"] / t["max"]
            pop = ui.ease_out_back(min(1.0, (1 - k) * 5))
            size = max(8, int(S(t["size"]) * (0.6 + 0.4 * pop)))
            ui.draw_text(surf, t["text"], size, t["color"], (t["x"] + origin[0], t["y"] + origin[1]),
                         bold=True, alpha=int(255 * min(1.0, k * 2)))


class ScreenShake:
    def __init__(self):
        self.power = 0.0

    def add(self, amount):
        self.power = min(30.0, self.power + amount)

    def update(self, dt):
        self.power *= math.exp(-7 * dt)
        if self.power < 0.3:
            self.power = 0.0

    def offset(self):
        if self.power <= 0:
            return 0, 0
        p = S(self.power)
        return random.randint(-p, p), random.randint(-p, p)


class Background:
    """Dégradé + vignette + orbes lumineuses qui dérivent lentement."""

    def __init__(self, count=14):
        self.key = None
        self.surface = None
        self.time = 0.0
        self.orbs = [{"x": random.random(), "y": random.random(), "r": random.uniform(60, 170),
                      "vx": random.uniform(-0.012, 0.012), "vy": random.uniform(-0.02, -0.004),
                      "phase": random.uniform(0, math.tau), "color": random.choice(("accent", "accent2", "snake_tail"))}
                     for _ in range(count)]

    def update(self, dt):
        self.time += dt
        for o in self.orbs:
            o["x"] = (o["x"] + o["vx"] * dt) % 1.0
            o["y"] = (o["y"] + o["vy"] * dt) % 1.0

    def _build(self, size, theme):
        surf = ui.vertical_gradient(size, theme["bg_top"], theme["bg_bottom"])
        # Vignette calculée en petit puis agrandie (rapide et doux)
        small = pygame.Surface((64, 36), pygame.SRCALPHA)
        for y in range(36):
            for x in range(64):
                d = math.hypot((x - 31.5) / 32, (y - 17.5) / 18)
                small.set_at((x, y), (0, 0, 0, int(200 * ui.clamp(d - 0.45) ** 1.5)))
        surf.blit(pygame.transform.smoothscale(small, size), (0, 0))
        return surf

    def draw(self, surf, theme):
        size = surf.get_size()
        key = (size, theme["name"])
        if key != self.key:
            self.key = key
            self.surface = self._build(size, theme)
        surf.blit(self.surface, (0, 0))
        w, h = size
        for o in self.orbs:
            pulse = 0.65 + 0.35 * math.sin(self.time * 0.8 + o["phase"])
            color = ui.darken(theme[o["color"]], 0.86 - 0.06 * pulse)
            ui.blit_glow(surf, (o["x"] * w, o["y"] * h), S(o["r"]), color)


class Transition:
    """Rideau de carrés en diagonale : ferme l'écran, exécute le callback, puis rouvre."""

    HALF = 0.42

    def __init__(self, callback):
        self.callback = callback
        self.phase = "out"
        self.t = 0.0
        self.done = False

    def update(self, dt):
        self.t += dt / self.HALF
        if self.t >= 1.0:
            if self.phase == "out":
                self.callback()
                self.phase = "in"
                self.t = 0.0
            else:
                self.done = True

    def draw(self, surf, theme):
        w, h = surf.get_size()
        tile = max(16, S(46))
        cols, rows = w // tile + 1, h // tile + 1
        span = cols + rows
        for j in range(rows):
            for i in range(cols):
                delay = (i + j) / span * 0.5
                local = ui.clamp((self.t - delay) / 0.5)
                cover = ui.ease_in_out(local) if self.phase == "out" else 1 - ui.ease_in_out(local)
                if cover <= 0.01:
                    continue
                size = int(tile * cover) + 2
                color = ui.lerp_color(theme["accent"], theme["bg_top"], 0.35 + 0.65 * cover)
                rect = pygame.Rect(0, 0, size, size)
                rect.center = (i * tile + tile // 2, j * tile + tile // 2)
                pygame.draw.rect(surf, color, rect, border_radius=int(tile * 0.3 * (1 - cover)))