LexiGuess.java

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.List;
import javax.sound.sampled.*;
import javax.swing.*;
import javax.swing.Timer;

public class LexiGuess extends JFrame {

    // ── Word Entry ────────────────────────────────────────────────────────────
    static class WordEntry {
        String word, clue, difficulty;
        WordEntry(String word, String clue, String difficulty) {
            this.word = word.toUpperCase().trim();
            this.clue = clue;
            this.difficulty = difficulty.toUpperCase().trim();
        }
    }

    // ── JSON Loader ───────────────────────────────────────────────────────────
    private static List<WordEntry> loadJson(String filePath) {
        List<WordEntry> entries = new ArrayList<>();
        try {
            String raw = new String(Files.readAllBytes(Paths.get(filePath)));
            String[] objects = raw.split("\\{");
            for (String obj : objects) {
                obj = obj.trim();
                if (obj.isEmpty()) continue;
                obj = obj.replaceAll("[}\\]]+\\s*$", "").trim();
                String word = extractJsonValue(obj, "words");
                if (word == null || word.isEmpty()) word = extractJsonValue(obj, "word");
                String clue = extractJsonValue(obj, "clue");
                String difficulty = extractJsonValue(obj, "difficulty");
                if (word != null && !word.isEmpty() && clue != null && difficulty != null)
                    entries.add(new WordEntry(word, clue, difficulty));
            }
        } catch (IOException e) {
            System.err.println("Could not load " + filePath + ": " + e.getMessage());
        }
        return entries;
    }

    private static String extractJsonValue(String obj, String key) {
        java.util.regex.Matcher m =
            java.util.regex.Pattern.compile("\"" + key + "\"\\s*:\\s*\"([^\"]+)\"").matcher(obj);
        return m.find() ? m.group(1).trim() : null;
    }

    // ── Word Banks ────────────────────────────────────────────────────────────
    private List<WordEntry> easyWords   = new ArrayList<>();
    private List<WordEntry> mediumWords = new ArrayList<>();
    private List<WordEntry> hardWords   = new ArrayList<>();

    private void loadAllWords() {
        easyWords   = loadJson("easy.json");
        mediumWords = loadJson("medium.json");
        hardWords   = loadJson("hard.json");
        if (easyWords.isEmpty()) for (String[] e : new String[][]{
            {"CODE","Instructions written for a computer to execute."},
            {"LOOP","A structure that repeats a block of code."},
            {"BYTE","A unit of data equal to 8 bits."},
            {"TYPE","A classification specifying the kind of value a variable holds."},
            {"VOID","A return type indicating a function returns nothing."}
        }) easyWords.add(new WordEntry(e[0], e[1], "EASY"));
        if (mediumWords.isEmpty()) for (String[] e : new String[][]{
            {"ARRAY","A collection of elements stored at contiguous memory locations."},
            {"STACK","A linear data structure following Last-In-First-Out order."},
            {"QUEUE","A linear data structure following First-In-First-Out order."},
            {"PARSE","To analyse a string of symbols according to formal grammar rules."},
            {"CACHE","Temporary storage that speeds up future data requests."}
        }) mediumWords.add(new WordEntry(e[0], e[1], "MEDIUM"));
        if (hardWords.isEmpty()) for (String[] e : new String[][]{
            {"MUTEX","A synchronisation primitive that prevents simultaneous resource access."},
            {"PRAGMA","A compiler directive that provides additional information to the compiler."},
            {"LAMBDA","An anonymous function defined without a name."},
            {"DAEMON","A background process that runs without direct user interaction."},
            {"ENDIAN","Describes the byte order used to represent multi-byte data."}
        }) hardWords.add(new WordEntry(e[0], e[1], "HARD"));
    }

    // ══════════════════════════════════════════════════════════════════════════
    //  FUTURISTIC COLOUR PALETTE
    // ══════════════════════════════════════════════════════════════════════════
    private static final Color BG_VOID        = new Color(4,  6,  14);
    private static final Color BG_DEEP        = new Color(8,  11, 22);
    private static final Color BG_SURFACE     = new Color(13, 17, 32);
    private static final Color BG_ELEVATED    = new Color(18, 23, 42);

    private static final Color AMBER          = new Color(255, 180, 30);
    private static final Color AMBER_DIM      = new Color(160, 105, 10);
    private static final Color AMBER_GLOW     = new Color(255, 140, 0,  70);
    private static final Color AMBER_SUBTLE   = new Color(255, 180, 30, 25);

    private static final Color CYAN           = new Color(50,  200, 255);
    private static final Color CYAN_DIM       = new Color(25,  110, 160);
    private static final Color CYAN_GLOW      = new Color(50,  200, 255, 60);

    private static final Color TEXT_BRIGHT    = new Color(230, 228, 218);
    private static final Color TEXT_MID       = new Color(150, 148, 165);
    private static final Color TEXT_DIM       = new Color(75,  73,  88);

    private static final Color TILE_EMPTY_BG  = new Color(16,  20,  38);
    private static final Color TILE_EMPTY_BD  = new Color(40,  44,  65);
    private static final Color GREEN_CORRECT  = new Color(40,  190, 110);
    private static final Color YELLOW_PRESENT = new Color(210, 165, 30);
    private static final Color GRAY_ABSENT    = new Color(38,  38,  52);
    private static final Color RED_DANGER     = new Color(210, 60,  60);

    private static final Color EASY_CLR       = new Color(50,  205, 120);
    private static final Color MEDIUM_CLR     = new Color(210, 165, 30);
    private static final Color HARD_CLR       = new Color(215, 75,  75);
    private static final Color CLUE_CLR       = new Color(100, 180, 255);

    // ── Sound ─────────────────────────────────────────────────────────────────
    private static final String SOUND_CORRECT  = "chrisiex1-correct-156911 (1).wav";
    private static final String SOUND_LOSE     = "freesound_community-080047_lose_funny_re.wav";
    private static final String SOUND_KEYCLICK = "creatorshome-keyboard-click-327728.wav";
    private static final String SOUND_START    = "creatorshome-keyboard-click-327728.wav";

    // ── Game State ────────────────────────────────────────────────────────────
    private WordEntry  currentEntry;
    private String     targetWord     = "";
    private String     currentClue    = "";
    private String     difficulty     = "EASY";
    private int        maxAttempts    = 6;
    private int        currentAttempt = 0;
    private int        sessionScore   = 0;
    private int        currentStage   = 1;
    private boolean    gameOver       = false;
    private boolean    gameWon        = false;
    private List<String>   guesses      = new ArrayList<>();
    private List<int[]>    feedbackList = new ArrayList<>();
    private Set<Character> correctLetters = new HashSet<>();
    private Set<Character> presentLetters = new HashSet<>();
    private Set<Character> absentLetters  = new HashSet<>();
    private Set<String>    usedWords      = new HashSet<>();
    private int            currentLevel   = 1;
    private int            totalLevels    = 0;
    private int            wordLength;

    private Map<String, Integer> difficultyProgress = new HashMap<>();
    private List<LeaderboardEntry> leaderboard       = new ArrayList<>();
    private String                 currentPlayerName = "Player";
    private final DatabaseManager  db = new DatabaseManager();

    // ── UI ────────────────────────────────────────────────────────────────────
    private CardLayout   cardLayout;
    private JPanel       cardPanel;
    private JLabel[][]   tiles;
    private JPanel       gridPanel;
    private HangmanPanel hangmanPanel;
    private JTextField   inputField;
    private JButton      submitBtn;
    private JLabel       messageLabel;
    private JLabel       clueLabel;
    private JLabel       difficultyLabel;
    private JLabel       inGameScoreLabel;
    private JLabel       sessionScoreLabel;
    private JLabel       stageLabel;
    private Map<Character, JLabel> keyLabels = new HashMap<>();
    private JPanel       keyboardPanel;
    private JPanel       leaderboardListPanel;
    private JPanel       levelSelectPanel;

    // ── Particle System ───────────────────────────────────────────────────────
    static class Particle {
        float x, y, vx, vy, life, maxLife, size;
        Color color;
        Particle(float x, float y, Color c) {
            this.x = x; this.y = y;
            float angle = (float)(Math.random() * Math.PI * 2);
            float speed = (float)(Math.random() * 0.6 + 0.15);
            vx = (float)Math.cos(angle) * speed;
            vy = (float)Math.sin(angle) * speed - 0.5f;
            life = maxLife = (float)(Math.random() * 220 + 80);
            size = (float)(Math.random() * 2.2 + 0.6);
            color = c;
        }
        void update() { x += vx; y += vy; vy += 0.012f; life--; }
        boolean dead() { return life <= 0; }
        float alpha() { return Math.max(0f, Math.min(1f, life / maxLife)); }
    }

    // ── Futuristic background panel ───────────────────────────────────────────
    static class FuturisticBackground extends JPanel {
        private final List<Particle> particles = new ArrayList<>();
        private Timer animTimer;
        private int frame = 0;

        FuturisticBackground() {
            setOpaque(true);
            animTimer = new Timer(24, e -> { frame++; spawnParticles(); updateParticles(); repaint(); });
            animTimer.start();
        }

        private void spawnParticles() {
            if (frame % 4 == 0 && particles.size() < 80) {
                int w = getWidth(); int h = getHeight();
                if (w == 0) return;
                float[] xs = {0, w, (float)(Math.random() * w)};
                float[] ys = {h, h, h + 10};
                int idx = (int)(Math.random() * xs.length);
                Color c = Math.random() > 0.5 ? new Color(255, 180, 30) : new Color(50, 200, 255);
                particles.add(new Particle(xs[idx], ys[idx], c));
            }
        }

        private void updateParticles() {
            particles.removeIf(Particle::dead);
            particles.forEach(Particle::update);
        }

        @Override
        protected void paintComponent(Graphics g) {
            Graphics2D g2 = (Graphics2D) g.create();
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,    RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setRenderingHint(RenderingHints.KEY_RENDERING,       RenderingHints.VALUE_RENDER_QUALITY);
            int w = getWidth(), h = getHeight();

            GradientPaint bg = new GradientPaint(0, 0, new Color(6, 8, 18), 0, h, new Color(4, 5, 12));
            g2.setPaint(bg); g2.fillRect(0, 0, w, h);

            RadialGradientPaint glowBL = new RadialGradientPaint(
                new Point2D.Float(0, h), Math.max(w, h) * 0.65f,
                new float[]{0f, 0.4f, 1f},
                new Color[]{new Color(200, 100, 0, 60), new Color(160, 60, 0, 18), new Color(0, 0, 0, 0)});
            g2.setPaint(glowBL); g2.fillRect(0, 0, w, h);

            RadialGradientPaint glowTR = new RadialGradientPaint(
                new Point2D.Float(w, 0), Math.max(w, h) * 0.55f,
                new float[]{0f, 0.35f, 1f},
                new Color[]{new Color(0, 100, 180, 45), new Color(0, 60, 120, 12), new Color(0, 0, 0, 0)});
            g2.setPaint(glowTR); g2.fillRect(0, 0, w, h);

            drawHexGrid(g2, w, h);
            drawCircuitLines(g2, w, h);

            for (Particle p : particles) {
                float a = p.alpha();
                int alphaMain = Math.max(0, Math.min(255, (int)(a * 200)));
                int alphaHalo = Math.max(0, Math.min(255, (int)(a * 40)));
                Color halo = new Color(p.color.getRed(), p.color.getGreen(), p.color.getBlue(), alphaHalo);
                g2.setColor(halo);
                g2.fill(new Ellipse2D.Float(p.x - p.size * 3, p.y - p.size * 3, p.size * 6, p.size * 6));
                Color pc = new Color(p.color.getRed(), p.color.getGreen(), p.color.getBlue(), alphaMain);
                g2.setColor(pc);
                g2.fill(new Ellipse2D.Float(p.x - p.size / 2, p.y - p.size / 2, p.size, p.size));
            }

            g2.setColor(new Color(0, 0, 0, 12));
            for (int y = 0; y < h; y += 3) g2.drawLine(0, y, w, y);

            g2.dispose();
            super.paintChildren(g);
        }

        private void drawHexGrid(Graphics2D g2, int w, int h) {
            int hexR = 38;
            int hexW = (int)(hexR * Math.sqrt(3));
            int hexH = hexR * 2;
            g2.setStroke(new BasicStroke(0.6f));
            for (int row = -1; row < h / (hexH * 3 / 4) + 2; row++) {
                for (int col = -1; col < w / hexW + 2; col++) {
                    int cx = col * hexW + (row % 2 == 1 ? hexW / 2 : 0);
                    int cy = row * (hexH * 3 / 4);
                    double distToCorner = Math.min(
                        Math.sqrt(cx * cx + (h - cy) * (h - cy)),
                        Math.sqrt((w - cx) * (w - cx) + cy * cy)) / Math.sqrt(w * w + h * h);
                    int alpha = (int)(8 + distToCorner * 10);
                    g2.setColor(new Color(80, 140, 200, Math.min(22, alpha)));
                    drawHex(g2, cx, cy, hexR);
                }
            }
        }

        private void drawHex(Graphics2D g2, int cx, int cy, int r) {
            int[] xs = new int[6], ys = new int[6];
            for (int i = 0; i < 6; i++) {
                double angle = Math.PI / 180.0 * (60 * i - 30);
                xs[i] = cx + (int)(r * Math.cos(angle));
                ys[i] = cy + (int)(r * Math.sin(angle));
            }
            g2.drawPolygon(xs, ys, 6);
        }

        private void drawCircuitLines(Graphics2D g2, int w, int h) {
            g2.setStroke(new BasicStroke(0.8f));
            Random rng = new Random(42);
            for (int i = 0; i < 12; i++) {
                int x1 = rng.nextInt(w), y1 = rng.nextInt(h);
                int x2 = x1 + (rng.nextBoolean() ? rng.nextInt(120) : 0);
                int y2 = y1 + (rng.nextBoolean() ? rng.nextInt(80) : 0);
                boolean isAmber = rng.nextBoolean();
                Color lc = isAmber ? new Color(255, 160, 20, 18) : new Color(30, 160, 220, 14);
                g2.setColor(lc);
                g2.drawLine(x1, y1, x2, y1);
                g2.drawLine(x2, y1, x2, y2);
                g2.setColor(new Color(lc.getRed(), lc.getGreen(), lc.getBlue(), 55));
                g2.fillOval(x2 - 3, y2 - 3, 6, 6);
            }
        }

        void stopAnimation() { if (animTimer != null) animTimer.stop(); }
    }

    // ── Transparent panel helper ──────────────────────────────────────────────
    private JPanel makeTransparentPanel() {
        JPanel p = new JPanel(); p.setOpaque(false); return p;
    }

    // ── Glow border button ────────────────────────────────────────────────────
    private JButton makeGlowButton(String text, Color accent) {
        JButton btn = new JButton(text) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 22));
                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                super.paintComponent(g2);
                g2.dispose();
            }
        };
        btn.setFont(new Font("Monospaced", Font.BOLD, 13));
        btn.setForeground(accent);
        btn.setContentAreaFilled(false); btn.setBorderPainted(false);
        btn.setFocusPainted(false); btn.setOpaque(false);
        btn.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn.setBorder(BorderFactory.createCompoundBorder(
            new GlowBorder(accent, 1, 8),
            BorderFactory.createEmptyBorder(7, 18, 7, 18)));
        btn.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                btn.setForeground(accent.brighter());
                btn.setBorder(BorderFactory.createCompoundBorder(
                    new GlowBorder(accent.brighter(), 2, 8),
                    BorderFactory.createEmptyBorder(6, 17, 6, 17)));
                btn.repaint();
            }
            public void mouseExited(MouseEvent e) {
                btn.setForeground(accent);
                btn.setBorder(BorderFactory.createCompoundBorder(
                    new GlowBorder(accent, 1, 8),
                    BorderFactory.createEmptyBorder(7, 18, 7, 18)));
                btn.repaint();
            }
        });
        return btn;
    }

    // ── Primary CTA button ────────────────────────────────────────────────────
    private JButton makePrimaryButton(String text) {
        JButton btn = new JButton(text) {
            private boolean hover = false;
            { addMouseListener(new MouseAdapter() {
                public void mouseEntered(MouseEvent e) { hover = true;  repaint(); }
                public void mouseExited (MouseEvent e) { hover = false; repaint(); }
            }); }
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                Color a = AMBER, b = new Color(200, 120, 0);
                if (hover) { a = a.brighter(); b = b.brighter(); }
                GradientPaint gp = new GradientPaint(0, 0, a, 0, getHeight(), b);
                g2.setPaint(gp);
                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 10, 10);
                g2.setColor(new Color(255, 180, 30, 60));
                g2.setStroke(new BasicStroke(3f));
                g2.drawRoundRect(1, 1, getWidth()-2, getHeight()-2, 10, 10);
                g2.dispose();
                super.paintComponent(g);
            }
        };
        btn.setFont(new Font("Monospaced", Font.BOLD, 18));
        btn.setForeground(new Color(10, 8, 2));
        btn.setContentAreaFilled(false); btn.setBorderPainted(false);
        btn.setFocusPainted(false); btn.setOpaque(false);
        btn.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn.setPreferredSize(new Dimension(260, 58));
        btn.setMaximumSize(new Dimension(260, 58));
        btn.setAlignmentX(CENTER_ALIGNMENT);
        return btn;
    }

    // ── Custom glow border ────────────────────────────────────────────────────
    static class GlowBorder extends javax.swing.border.AbstractBorder {
        private final Color color; private final int thick, radius;
        GlowBorder(Color c, int t, int r) { color = c; thick = t; radius = r; }
        @Override public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
            Graphics2D g2 = (Graphics2D) g.create();
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setColor(new Color(color.getRed(), color.getGreen(), color.getBlue(), 35));
            g2.setStroke(new BasicStroke(thick + 4));
            g2.drawRoundRect(x+2, y+2, w-4, h-4, radius+2, radius+2);
            g2.setColor(color);
            g2.setStroke(new BasicStroke(thick));
            g2.drawRoundRect(x+1, y+1, w-2, h-2, radius, radius);
            g2.dispose();
        }
        @Override public Insets getBorderInsets(Component c) { return new Insets(thick+2, thick+2, thick+2, thick+2); }
    }

    // ── Section title ─────────────────────────────────────────────────────────
    private JLabel makeSectionTitle(String text) {
        JLabel lbl = new JLabel(text, SwingConstants.CENTER) {
            @Override protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                Graphics2D g2 = (Graphics2D) g.create();
                int mid = getWidth() / 2;
                int y = getHeight() - 5;
                GradientPaint fade  = new GradientPaint(mid - 60, y, new Color(255, 180, 30, 0), mid, y, AMBER, false);
                GradientPaint fade2 = new GradientPaint(mid, y, AMBER, mid + 60, y, new Color(255, 180, 30, 0), false);
                g2.setStroke(new BasicStroke(1.5f));
                g2.setPaint(fade);  g2.drawLine(mid - 60, y, mid, y);
                g2.setPaint(fade2); g2.drawLine(mid, y, mid + 60, y);
                g2.dispose();
            }
        };
        lbl.setFont(new Font("Monospaced", Font.BOLD, 14));
        lbl.setForeground(AMBER_DIM);
        lbl.setAlignmentX(CENTER_ALIGNMENT);
        lbl.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
        return lbl;
    }

    private JLabel makeHexOrnament(String text) {
        JLabel lbl = new JLabel(text, SwingConstants.CENTER);
        lbl.setFont(new Font("Monospaced", Font.PLAIN, 11));
        lbl.setForeground(new Color(80, 70, 35));
        lbl.setAlignmentX(CENTER_ALIGNMENT);
        return lbl;
    }

    // ── Sound ─────────────────────────────────────────────────────────────────
    private void playSound(String filePath) {
        new Thread(() -> {
            try {
                File f = new File(filePath); if (!f.exists()) return;
                AudioInputStream ai = AudioSystem.getAudioInputStream(f);
                Clip clip = AudioSystem.getClip(); clip.open(ai); clip.start();
                clip.addLineListener(ev -> { if (ev.getType() == LineEvent.Type.STOP) clip.close(); });
            } catch (Exception ignored) {}
        }).start();
    }

    // ── Constructor ───────────────────────────────────────────────────────────
    public LexiGuess() {
        loadAllWords(); db.connect();
        Runtime.getRuntime().addShutdownHook(new Thread(db::disconnect));
        difficultyProgress.put("EASY", 1); difficultyProgress.put("MEDIUM", 1); difficultyProgress.put("HARD", 1);

        setTitle("LexiGuess — Programming Enhancement Game");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
        getContentPane().setBackground(BG_VOID);

        cardLayout = new CardLayout(); cardPanel = new JPanel(cardLayout);
        cardPanel.setBackground(BG_VOID);
        cardPanel.add(buildStartScreen(),        "START");
        cardPanel.add(buildMenuScreen(),         "MENU");
        cardPanel.add(buildLevelSelectScreen(),  "LEVELSELECT");
        cardPanel.add(buildGameScreen(),         "GAME");
        cardPanel.add(buildInstructionsScreen(), "INSTRUCTIONS");
        cardPanel.add(buildLeaderboardScreen(),  "LEADERBOARD");

        add(cardPanel);
        setSize(980, 840);
        setLocationRelativeTo(null);
        setVisible(true);
        cardLayout.show(cardPanel, "START");
    }

    // ── End Game Dialog ───────────────────────────────────────────────────────
    private void showEndGameDialog(String title, String message, String word,
                                    String subMessage, Color accentColor, String retryLabel) {
        JDialog dialog = new JDialog(this, title, true);
        dialog.setUndecorated(true);
        dialog.setSize(480, 400);
        dialog.setLocationRelativeTo(this);

        JPanel panel = new JPanel() {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(BG_SURFACE);
                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 20, 20);
                GradientPaint topBar = new GradientPaint(0, 0,
                    new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 180),
                    getWidth(), 0, new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 0));
                g2.setPaint(topBar); g2.fillRoundRect(0, 0, getWidth(), 4, 20, 20);
                g2.setColor(new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 80));
                g2.setStroke(new BasicStroke(2f));
                g2.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 20, 20);
                RadialGradientPaint innerGlow = new RadialGradientPaint(
                    new Point2D.Float(getWidth()/2f, 0), getWidth()/2f,
                    new float[]{0f, 1f},
                    new Color[]{new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 25), new Color(0,0,0,0)});
                g2.setPaint(innerGlow); g2.fillRect(0, 0, getWidth(), 80);
                g2.dispose();
            }
        };
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
        panel.setBorder(BorderFactory.createEmptyBorder(30, 45, 28, 45));
        panel.setOpaque(false);

        JLabel hex = makeHexOrnament("[ ◈ SYSTEM REPORT ◈ ]");
        hex.setForeground(new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 130));
        panel.add(hex); panel.add(Box.createVerticalStrut(10));

        JLabel titleLabel = new JLabel(title, SwingConstants.CENTER);
        titleLabel.setFont(new Font("Monospaced", Font.BOLD, 26));
        titleLabel.setForeground(accentColor.equals(RED_DANGER) ? RED_DANGER : AMBER);
        titleLabel.setAlignmentX(CENTER_ALIGNMENT);
        panel.add(titleLabel); panel.add(Box.createVerticalStrut(10));

        JLabel msgLabel = new JLabel(message, SwingConstants.CENTER);
        msgLabel.setFont(new Font("Monospaced", Font.PLAIN, 12)); msgLabel.setForeground(TEXT_MID);
        msgLabel.setAlignmentX(CENTER_ALIGNMENT);
        panel.add(msgLabel); panel.add(Box.createVerticalStrut(8));

        JLabel wordLabel = new JLabel(word, SwingConstants.CENTER) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 30));
                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                g2.setColor(new Color(accentColor.getRed(), accentColor.getGreen(), accentColor.getBlue(), 90));
                g2.setStroke(new BasicStroke(1f));
                g2.drawRoundRect(0, 0, getWidth()-1, getHeight()-1, 8, 8);
                g2.dispose();
                super.paintComponent(g);
            }
        };
        wordLabel.setFont(new Font("Monospaced", Font.BOLD, 36));
        wordLabel.setForeground(TEXT_BRIGHT);
        wordLabel.setAlignmentX(CENTER_ALIGNMENT);
        wordLabel.setBorder(BorderFactory.createEmptyBorder(6, 20, 6, 20));
        wordLabel.setOpaque(false);
        panel.add(wordLabel); panel.add(Box.createVerticalStrut(10));

        JLabel clueDialogLabel = new JLabel(
            "<html><div style='text-align:center;width:340px;font-family:monospace'>" + currentClue + "</div></html>",
            SwingConstants.CENTER);
        clueDialogLabel.setFont(new Font("Monospaced", Font.ITALIC, 12));
        clueDialogLabel.setForeground(CLUE_CLR); clueDialogLabel.setAlignmentX(CENTER_ALIGNMENT);
        panel.add(clueDialogLabel); panel.add(Box.createVerticalStrut(6));

        JLabel subLabel = new JLabel(subMessage, SwingConstants.CENTER);
        subLabel.setFont(new Font("Monospaced", Font.BOLD, 13));
        subLabel.setForeground(accentColor.equals(RED_DANGER) ? RED_DANGER : AMBER);
        subLabel.setAlignmentX(CENTER_ALIGNMENT);
        panel.add(subLabel); panel.add(Box.createVerticalStrut(26));

        JPanel btnPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 14, 0));
        btnPanel.setOpaque(false);
        JButton retryBtn = makeGlowButton(retryLabel, accentColor.equals(RED_DANGER) ? RED_DANGER : GREEN_CORRECT);
        retryBtn.addActionListener(e -> { dialog.dispose(); startGame(); });
        JButton lvlBtn = makeGlowButton("Level Select", AMBER);
        lvlBtn.addActionListener(e -> { dialog.dispose(); updateLevelSelectScreen(); cardLayout.show(cardPanel, "LEVELSELECT"); });
        JButton exitBtn = makeGlowButton("Exit", TEXT_MID);
        exitBtn.addActionListener(e -> System.exit(0));
        btnPanel.add(retryBtn); btnPanel.add(lvlBtn); btnPanel.add(exitBtn);
        btnPanel.setAlignmentX(CENTER_ALIGNMENT);
        panel.add(btnPanel);

        dialog.setContentPane(panel);
        dialog.getContentPane().setBackground(BG_SURFACE);
        dialog.setVisible(true);
    }

    // ── Start Screen ──────────────────────────────────────────────────────────
    private JPanel buildStartScreen() {
        FuturisticBackground root = new FuturisticBackground();
        root.setLayout(new BorderLayout());

        JPanel center = makeTransparentPanel();
        center.setLayout(new BoxLayout(center, BoxLayout.Y_AXIS));
        center.setBorder(BorderFactory.createEmptyBorder(80, 100, 80, 100));

        JLabel hexTag = makeHexOrnament("◈ v2.0  ·  programming_challenge.exe  ◈");
        hexTag.setFont(new Font("Monospaced", Font.PLAIN, 12));
        hexTag.setForeground(CYAN_DIM);
        center.add(hexTag);
        center.add(Box.createVerticalStrut(18));

        JLabel title = new JLabel("LexiGuess", SwingConstants.CENTER) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setFont(getFont()); g2.setColor(new Color(255, 160, 0, 55));
                g2.drawString(getText(), 3, getHeight() - 18);
                g2.dispose();
                super.paintComponent(g);
            }
        };
        title.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 82));
        title.setForeground(AMBER);
        title.setAlignmentX(CENTER_ALIGNMENT);
        center.add(title);

        JLabel sub = new JLabel("Programming Enhancement Game", SwingConstants.CENTER);
        sub.setFont(new Font("Monospaced", Font.PLAIN, 15));
        sub.setForeground(TEXT_MID); sub.setAlignmentX(CENTER_ALIGNMENT);
        center.add(sub);
        center.add(Box.createVerticalStrut(6));

        JPanel sep = makeSeparatorLine(AMBER, 180);
        sep.setAlignmentX(CENTER_ALIGNMENT);
        center.add(sep);
        center.add(Box.createVerticalStrut(38));

        JLabel nameLbl = makeHexOrnament("//  player_name");
        nameLbl.setFont(new Font("Monospaced", Font.PLAIN, 13)); nameLbl.setForeground(CYAN_DIM);
        center.add(nameLbl); center.add(Box.createVerticalStrut(8));

        JTextField nameField = new JTextField("Player", 15) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(14, 20, 40)); g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                g2.setColor(new Color(50, 200, 255, 80)); g2.setStroke(new BasicStroke(1f));
                g2.drawRoundRect(0, 0, getWidth()-1, getHeight()-1, 8, 8);
                g2.dispose();
                super.paintComponent(g);
            }
        };
        nameField.setFont(new Font("Monospaced", Font.BOLD, 18));
        nameField.setForeground(TEXT_BRIGHT); nameField.setOpaque(false);
        nameField.setBackground(new Color(0,0,0,0)); nameField.setCaretColor(AMBER);
        nameField.setHorizontalAlignment(SwingConstants.CENTER);
        nameField.setBorder(BorderFactory.createEmptyBorder(10, 16, 10, 16));
        nameField.setMaximumSize(new Dimension(280, 50)); nameField.setAlignmentX(CENTER_ALIGNMENT);
        center.add(nameField);
        center.add(Box.createVerticalStrut(36));

        JButton startBtn = makePrimaryButton("▶  START GAME");
        startBtn.addActionListener(e -> {
            String name = nameField.getText().trim();
            if (!name.isEmpty()) currentPlayerName = name;
            if (db.isConnected()) {
                java.util.Map<String, Integer> saved = db.loadAllProgress(currentPlayerName);
                difficultyProgress.put("EASY",   saved.get("EASY"));
                difficultyProgress.put("MEDIUM", saved.get("MEDIUM"));
                difficultyProgress.put("HARD",   saved.get("HARD"));
            }
            playSound(SOUND_START); cardLayout.show(cardPanel, "MENU");
        });
        center.add(startBtn); center.add(Box.createVerticalStrut(14));

        JPanel rowBtns = new JPanel(new FlowLayout(FlowLayout.CENTER, 12, 0));
        rowBtns.setOpaque(false); rowBtns.setAlignmentX(CENTER_ALIGNMENT);
        JButton leaderBtn = makeGlowButton("★  Leaderboard", AMBER_DIM);
        leaderBtn.addActionListener(e -> { updateLeaderboardDisplay(); cardLayout.show(cardPanel, "LEADERBOARD"); });
        JButton exitBtn = makeGlowButton("✕  Exit", new Color(140, 50, 50));
        exitBtn.addActionListener(e -> System.exit(0));
        rowBtns.add(leaderBtn); rowBtns.add(exitBtn);
        center.add(rowBtns);
        center.add(Box.createVerticalStrut(28));
        JLabel hint = makeHexOrnament("//.  Awaiting input...  ready to compile your first guess");
        hint.setForeground(new Color(40, 60, 30));
        center.add(hint);

        root.add(center, BorderLayout.CENTER);
        return root;
    }

    private JPanel makeSeparatorLine(Color c, int width) {
        return new JPanel() {
            { setOpaque(false); setPreferredSize(new Dimension(width, 2));
              setMaximumSize(new Dimension(width, 2)); }
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                GradientPaint gp  = new GradientPaint(0, 0, new Color(c.getRed(), c.getGreen(), c.getBlue(), 0), getWidth()/2, 0, c, false);
                GradientPaint gp2 = new GradientPaint(getWidth()/2, 0, c, getWidth(), 0, new Color(c.getRed(), c.getGreen(), c.getBlue(), 0), false);
                g2.setPaint(gp);  g2.fillRect(0, 0, getWidth()/2, getHeight());
                g2.setPaint(gp2); g2.fillRect(getWidth()/2, 0, getWidth()/2, getHeight());
                g2.dispose();
            }
        };
    }

    // ── Menu Screen ───────────────────────────────────────────────────────────
    private JPanel buildMenuScreen() {
        FuturisticBackground root = new FuturisticBackground();
        root.setLayout(new BorderLayout());

        JPanel topBar = new JPanel(new BorderLayout()) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(8, 11, 22, 200)); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.setColor(new Color(255, 180, 30, 50)); g2.setStroke(new BasicStroke(1f));
                g2.drawLine(0, getHeight()-1, getWidth(), getHeight()-1);
                g2.dispose();
            }
        };
        topBar.setOpaque(false);
        topBar.setBorder(BorderFactory.createEmptyBorder(10, 20, 10, 20));

        JLabel logoSmall = new JLabel("⬡ LexiGuess", SwingConstants.LEFT);
        logoSmall.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 22)); logoSmall.setForeground(AMBER);
        topBar.add(logoSmall, BorderLayout.WEST);

        JPanel navRight = new JPanel(new FlowLayout(FlowLayout.RIGHT, 16, 0));
        navRight.setOpaque(false);
        JButton instrBtn  = makeGlowButton("[ How to Play ]", AMBER_DIM);
        instrBtn.addActionListener(e -> cardLayout.show(cardPanel, "INSTRUCTIONS"));
        JButton leaderBtn = makeGlowButton("[ Leaderboard ]", CYAN_DIM);
        leaderBtn.addActionListener(e -> { updateLeaderboardDisplay(); cardLayout.show(cardPanel, "LEADERBOARD"); });
        JButton exitBtn   = makeGlowButton("[ Exit ]", new Color(120, 45, 45));
        exitBtn.addActionListener(e -> System.exit(0));
        navRight.add(instrBtn); navRight.add(leaderBtn); navRight.add(exitBtn);
        topBar.add(navRight, BorderLayout.EAST);
        root.add(topBar, BorderLayout.NORTH);

        JPanel center = makeTransparentPanel();
        center.setLayout(new BoxLayout(center, BoxLayout.Y_AXIS));
        center.setBorder(BorderFactory.createEmptyBorder(22, 60, 20, 60));

        center.add(makeSectionTitle("◈  SELECT YOUR CHALLENGE  ◈"));
        center.add(Box.createVerticalStrut(22));

        JPanel diffRow = new JPanel(new FlowLayout(FlowLayout.CENTER, 22, 0));
        diffRow.setOpaque(false);
        diffRow.add(makeDiffCard("EASY",   "Novice",     "Common concepts",    EASY_CLR,   easyWords.size()));
        diffRow.add(makeDiffCard("MEDIUM", "Scholar",    "Intermediate terms", MEDIUM_CLR, mediumWords.size()));
        diffRow.add(makeDiffCard("HARD",   "Mastermind", "Advanced jargon",    HARD_CLR,   hardWords.size()));
        center.add(diffRow);
        center.add(Box.createVerticalStrut(28));

        sessionScoreLabel = new JLabel("[ Session Score: 0  ·  Stage: 1 ]", SwingConstants.CENTER);
        sessionScoreLabel.setFont(new Font("Monospaced", Font.BOLD, 15));
        sessionScoreLabel.setForeground(AMBER); sessionScoreLabel.setAlignmentX(CENTER_ALIGNMENT);
        center.add(sessionScoreLabel);

        root.add(center, BorderLayout.CENTER);

        JPanel statusBar = new JPanel(new FlowLayout(FlowLayout.CENTER)) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(6, 9, 18, 180)); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.setColor(new Color(255, 180, 30, 35)); g2.drawLine(0, 0, getWidth(), 0);
                g2.dispose();
            }
        };
        statusBar.setOpaque(false);
        JLabel statusLbl = new JLabel("◈ SYSTEM ONLINE  ·  DATABASE CONNECTED  ·  AWAITING SELECTION ◈");
        statusLbl.setFont(new Font("Monospaced", Font.PLAIN, 10)); statusLbl.setForeground(new Color(50, 50, 35));
        statusBar.add(statusLbl);
        root.add(statusBar, BorderLayout.SOUTH);
        return root;
    }

    // ── Difficulty Card ───────────────────────────────────────────────────────
    private JPanel makeDiffCard(String diff, String rankTitle, String descriptor,
                                 Color accent, int wordCount) {
        JPanel card = new JPanel() {
            private boolean hover = false;
            { setOpaque(false);
              addMouseListener(new MouseAdapter() {
                public void mouseEntered(MouseEvent e) { hover = true;  repaint(); }
                public void mouseExited (MouseEvent e) { hover = false; repaint(); }
              }); }
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(accent.getRed()/5, accent.getGreen()/5, accent.getBlue()/5, 255));
                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 16, 16);
                g2.setColor(new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 8));
                for (int y = 0; y < getHeight(); y += 22)
                    for (int x = 0; x < getWidth(); x += 28)
                        drawMiniHex(g2, x + (y/22 % 2 == 0 ? 0 : 14), y);
                if (hover) {
                    g2.setColor(new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 100));
                    g2.setStroke(new BasicStroke(3f));
                    g2.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 15, 15);
                    GradientPaint topGlow = new GradientPaint(0, 0,
                        new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 160),
                        getWidth(), 0, new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 0));
                    g2.setPaint(topGlow); g2.fillRoundRect(0, 0, getWidth(), 3, 15, 15);
                } else {
                    g2.setColor(new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 60));
                    g2.setStroke(new BasicStroke(1.5f));
                    g2.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 15, 15);
                }
                g2.dispose();
                super.paintComponent(g);
            }
            private void drawMiniHex(Graphics2D g2, int cx, int cy) {
                int r = 9; int[] xs = new int[6], ys = new int[6];
                for (int i = 0; i < 6; i++) {
                    double ang = Math.PI / 180.0 * (60*i - 30);
                    xs[i] = cx + (int)(r * Math.cos(ang)); ys[i] = cy + (int)(r * Math.sin(ang));
                }
                g2.drawPolygon(xs, ys, 6);
            }
        };
        card.setLayout(new BoxLayout(card, BoxLayout.Y_AXIS));
        card.setPreferredSize(new Dimension(218, 255));
        card.setBorder(BorderFactory.createEmptyBorder(20, 18, 20, 18));
        card.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        JPanel accentLine = new JPanel() {
            { setOpaque(false); setMaximumSize(new Dimension(180, 2)); }
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                GradientPaint gp  = new GradientPaint(0, 0, new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 0), getWidth()/2, 0, accent, false);
                GradientPaint gp2 = new GradientPaint(getWidth()/2, 0, accent, getWidth(), 0, new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 0), false);
                g2.setPaint(gp);  g2.fillRect(0, 0, getWidth()/2, getHeight());
                g2.setPaint(gp2); g2.fillRect(getWidth()/2, 0, getWidth()/2, getHeight());
                g2.dispose();
            }
        };
        accentLine.setAlignmentX(CENTER_ALIGNMENT);

        JLabel diffLbl = new JLabel(diff, SwingConstants.CENTER);
        diffLbl.setFont(new Font("Monospaced", Font.BOLD, 22)); diffLbl.setForeground(accent);
        diffLbl.setAlignmentX(CENTER_ALIGNMENT);

        JLabel rankLbl = new JLabel("[ " + rankTitle + " ]", SwingConstants.CENTER);
        rankLbl.setFont(new Font("Monospaced", Font.PLAIN, 11));
        rankLbl.setForeground(new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 160));
        rankLbl.setAlignmentX(CENTER_ALIGNMENT);

        JLabel descLbl = new JLabel(descriptor, SwingConstants.CENTER);
        descLbl.setFont(new Font("Monospaced", Font.PLAIN, 11)); descLbl.setForeground(TEXT_MID);
        descLbl.setAlignmentX(CENTER_ALIGNMENT);

        JLabel countLbl = new JLabel("6 attempts  ·  " + wordCount + " levels", SwingConstants.CENTER);
        countLbl.setFont(new Font("Monospaced", Font.PLAIN, 10)); countLbl.setForeground(TEXT_DIM);
        countLbl.setAlignmentX(CENTER_ALIGNMENT);

        JLabel clueLbl = new JLabel("✦ Clue included", SwingConstants.CENTER);
        clueLbl.setFont(new Font("Monospaced", Font.PLAIN, 10)); clueLbl.setForeground(CYAN_DIM);
        clueLbl.setAlignmentX(CENTER_ALIGNMENT);

        JButton playBtn = makeGlowButton("SELECT LEVEL  →", accent);
        playBtn.setFont(new Font("Monospaced", Font.BOLD, 11));
        playBtn.setMaximumSize(new Dimension(170, 34)); playBtn.setAlignmentX(CENTER_ALIGNMENT);
        playBtn.addActionListener(e -> {
            difficulty = diff;
            currentLevel = difficultyProgress.getOrDefault(diff, 1);
            updateLevelSelectScreen();
            cardLayout.show(cardPanel, "LEVELSELECT");
        });

        card.add(accentLine); card.add(Box.createVerticalStrut(10));
        card.add(diffLbl); card.add(rankLbl); card.add(Box.createVerticalStrut(10));
        card.add(descLbl); card.add(countLbl); card.add(Box.createVerticalStrut(4));
        card.add(clueLbl); card.add(Box.createVerticalGlue()); card.add(playBtn);
        return card;
    }

    // ── Level Select Screen ───────────────────────────────────────────────────
    private JPanel buildLevelSelectScreen() {
        FuturisticBackground root = new FuturisticBackground();
        root.setLayout(new BorderLayout());

        JPanel topBar = new JPanel(new BorderLayout()) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(6, 9, 20, 220)); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.setColor(new Color(255, 180, 30, 45)); g2.drawLine(0, getHeight()-1, getWidth(), getHeight()-1);
                g2.dispose();
            }
        };
        topBar.setOpaque(false);
        topBar.setBorder(BorderFactory.createEmptyBorder(12, 20, 12, 20));
        JButton backBtn = makeGlowButton("← Back", AMBER_DIM);
        backBtn.addActionListener(e -> cardLayout.show(cardPanel, "MENU"));
        topBar.add(backBtn, BorderLayout.WEST);
        JLabel titleLbl = new JLabel("◈  SKILL TREE  ◈", SwingConstants.CENTER);
        titleLbl.setFont(new Font("Monospaced", Font.BOLD, 22)); titleLbl.setForeground(AMBER);
        topBar.add(titleLbl, BorderLayout.CENTER);
        root.add(topBar, BorderLayout.NORTH);

        levelSelectPanel = new JPanel();
        levelSelectPanel.setOpaque(false);
        levelSelectPanel.setBorder(BorderFactory.createEmptyBorder(28, 50, 28, 50));
        JScrollPane scroll = new JScrollPane(levelSelectPanel);
        scroll.setOpaque(false); scroll.getViewport().setOpaque(false); scroll.setBorder(null);
        scroll.getVerticalScrollBar().setUnitIncrement(16);
        scroll.getVerticalScrollBar().setBackground(BG_DEEP);
        root.add(scroll, BorderLayout.CENTER);

        JPanel botBar = new JPanel(new FlowLayout(FlowLayout.CENTER)) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(6, 9, 20, 180)); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.dispose();
            }
        };
        botBar.setOpaque(false);
        JLabel botLbl = new JLabel("◈  Defeat each level to unlock the next node  ◈");
        botLbl.setFont(new Font("Monospaced", Font.PLAIN, 10)); botLbl.setForeground(new Color(50, 50, 35));
        botBar.add(botLbl); root.add(botBar, BorderLayout.SOUTH);
        return root;
    }

    private void updateLevelSelectScreen() {
        levelSelectPanel.removeAll();
        levelSelectPanel.setLayout(new BoxLayout(levelSelectPanel, BoxLayout.Y_AXIS));
        List<WordEntry> bank = difficulty.equals("EASY") ? easyWords
                             : difficulty.equals("MEDIUM") ? mediumWords : hardWords;
        totalLevels = bank.size();
        Color accent = difficulty.equals("EASY") ? EASY_CLR : difficulty.equals("MEDIUM") ? MEDIUM_CLR : HARD_CLR;
        int highestUnlocked = difficultyProgress.getOrDefault(difficulty, 1);

        JLabel diffLbl = new JLabel(difficulty + "  —  Skill Tree", SwingConstants.CENTER);
        diffLbl.setFont(new Font("Monospaced", Font.BOLD, 20)); diffLbl.setForeground(accent);
        diffLbl.setAlignmentX(CENTER_ALIGNMENT); levelSelectPanel.add(diffLbl);

        int cleared = highestUnlocked - 1;
        JLabel progressLbl = new JLabel(cleared + " of " + totalLevels + " nodes cleared", SwingConstants.CENTER);
        progressLbl.setFont(new Font("Monospaced", Font.PLAIN, 12)); progressLbl.setForeground(TEXT_MID);
        progressLbl.setAlignmentX(CENTER_ALIGNMENT);
        levelSelectPanel.add(Box.createVerticalStrut(6)); levelSelectPanel.add(progressLbl);

        JPanel progressBarWrapper = new JPanel() {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(20, 24, 40)); g2.fillRoundRect(0, 4, getWidth(), 6, 6, 6);
                if (totalLevels > 0) {
                    int filled = (int)((double)cleared / totalLevels * getWidth());
                    GradientPaint gp = new GradientPaint(0, 0, accent.darker(), filled, 0, accent);
                    g2.setPaint(gp); g2.fillRoundRect(0, 4, filled, 6, 6, 6);
                }
                g2.dispose();
            }
        };
        progressBarWrapper.setOpaque(false);
        progressBarWrapper.setPreferredSize(new Dimension(600, 14));
        progressBarWrapper.setMaximumSize(new Dimension(600, 14));
        progressBarWrapper.setAlignmentX(CENTER_ALIGNMENT);
        levelSelectPanel.add(Box.createVerticalStrut(8)); levelSelectPanel.add(progressBarWrapper);
        levelSelectPanel.add(Box.createVerticalStrut(24));

        int cols = 5;
        int rows = (int) Math.ceil((double) totalLevels / cols);
        JPanel grid = new JPanel(new GridLayout(rows, cols, 18, 18));
        grid.setOpaque(false);
        grid.setMaximumSize(new Dimension(680, rows * 115));
        grid.setAlignmentX(CENTER_ALIGNMENT);

        for (int i = 1; i <= totalLevels; i++) {
            final int lvl = i;
            boolean isCleared  = (i < highestUnlocked);
            boolean isUnlocked = (i <= highestUnlocked);
            boolean isCurrent  = (i == highestUnlocked);

            JPanel cell = new JPanel() {
                private boolean hover = false;
                { if (isUnlocked) addMouseListener(new MouseAdapter() {
                    public void mouseEntered(MouseEvent e) { hover = true;  repaint(); }
                    public void mouseExited (MouseEvent e) { hover = false; repaint(); }
                }); }
                @Override protected void paintComponent(Graphics g) {
                    Graphics2D g2 = (Graphics2D) g.create();
                    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                    Color bg;
                    if (isCleared)       bg = new Color(accent.getRed()/7, accent.getGreen()/7, accent.getBlue()/7, 255);
                    else if (isUnlocked) bg = new Color(18, 22, 42);
                    else                 bg = new Color(10, 12, 24);
                    g2.setColor(bg); g2.fillRoundRect(0, 0, getWidth(), getHeight(), 14, 14);
                    float thick = (hover || isCurrent) ? 2.5f : 1.2f;
                    Color bd = isCleared ? accent
                             : isCurrent ? new Color(accent.getRed(), accent.getGreen(), accent.getBlue(), 200)
                             : isUnlocked ? new Color(AMBER_DIM.getRed(), AMBER_DIM.getGreen(), AMBER_DIM.getBlue(), hover ? 180 : 80)
                             : new Color(28, 30, 45);
                    g2.setColor(bd); g2.setStroke(new BasicStroke(thick));
                    g2.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 13, 13);
                    g2.dispose();
                    super.paintComponent(g);
                }
            };
            cell.setLayout(new BoxLayout(cell, BoxLayout.Y_AXIS));
            cell.setOpaque(false);
            cell.setPreferredSize(new Dimension(114, 98));
            cell.setBorder(BorderFactory.createEmptyBorder(10, 8, 10, 8));
            if (isUnlocked) cell.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

            String numText  = isUnlocked ? String.valueOf(lvl) : "⬡";
            JLabel numLbl   = new JLabel(numText, SwingConstants.CENTER);
            numLbl.setFont(new Font("Monospaced", Font.BOLD, isUnlocked ? 28 : 18));
            numLbl.setForeground(isCleared ? accent : isUnlocked ? TEXT_BRIGHT : new Color(35, 35, 50));
            numLbl.setAlignmentX(CENTER_ALIGNMENT);

            String statusText = isCleared ? "✦ Cleared" : isCurrent ? "▶ Play" : isUnlocked ? "Unlocked" : "Locked";
            JLabel statusLbl  = new JLabel(statusText, SwingConstants.CENTER);
            statusLbl.setFont(new Font("Monospaced", Font.PLAIN, 10));
            statusLbl.setForeground(isCleared ? accent : isCurrent ? AMBER : isUnlocked ? TEXT_MID : new Color(35,35,50));
            statusLbl.setAlignmentX(CENTER_ALIGNMENT);

            cell.add(Box.createVerticalGlue());
            cell.add(numLbl); cell.add(Box.createVerticalStrut(5)); cell.add(statusLbl);
            cell.add(Box.createVerticalGlue());

            if (isUnlocked) cell.addMouseListener(new MouseAdapter() {
                @Override public void mouseClicked(MouseEvent e) {
                    currentLevel = lvl; usedWords.clear(); startGame();
                }
            });
            grid.add(cell);
        }
        levelSelectPanel.add(grid);
        levelSelectPanel.revalidate(); levelSelectPanel.repaint();
    }

    // ── Instructions Screen ───────────────────────────────────────────────────
    private JPanel buildInstructionsScreen() {
        FuturisticBackground root = new FuturisticBackground();
        root.setLayout(new BorderLayout());
        root.setBorder(BorderFactory.createEmptyBorder(28, 65, 28, 65));

        JLabel title = new JLabel("◈  HOW TO PLAY  ◈", SwingConstants.CENTER);
        title.setFont(new Font("Monospaced", Font.BOLD, 28)); title.setForeground(AMBER);
        title.setBorder(BorderFactory.createEmptyBorder(0, 0, 16, 0));
        root.add(title, BorderLayout.NORTH);

        String html = "<html><body style='background:#080b16;color:#9694a5;font-family:monospace;padding:18px;'>"
            + "<h2 style='color:#ffb41e;'>◈ Objective</h2>"
            + "<p>Decipher the hidden programming word within 6 attempts to claim victory and advance to the next node.</p><br>"
            + "<h2 style='color:#ffb41e;'>◈ Skill Tree / Levels</h2>"
            + "<p>Each difficulty has its own set of levels. Complete a level to unlock the next node.</p><br>"
            + "<h2 style='color:#ffb41e;'>◈ Clue System</h2>"
            + "<p>Every word comes with a <span style='color:#64b4ff;'>clue</span> displayed beneath the grid.</p><br>"
            + "<h2 style='color:#ffb41e;'>◈ Difficulty</h2>"
            + "<table border='0' cellpadding='6'>"
            + "<tr><td style='color:#32cd78;font-weight:bold;'>[ EASY ]</td><td>Everyday concepts any beginner knows</td></tr>"
            + "<tr><td style='color:#d2a51e;font-weight:bold;'>[ MEDIUM ]</td><td>Intermediate terms encountered during learning</td></tr>"
            + "<tr><td style='color:#d74b4b;font-weight:bold;'>[ HARD ]</td><td>Advanced / niche jargon for seasoned developers</td></tr>"
            + "</table><br>"
            + "<h2 style='color:#ffb41e;'>◈ Colour Feedback</h2>"
            + "<table border='0' cellpadding='6'>"
            + "<tr><td style='color:#28be6e;font-weight:bold;'>GREEN</td><td>Correct letter, correct position</td></tr>"
            + "<tr><td style='color:#d2a51e;font-weight:bold;'>AMBER</td><td>Letter exists but wrong position</td></tr>"
            + "<tr><td style='color:#787682;font-weight:bold;'>GREY</td><td>Letter not in the word at all</td></tr>"
            + "</table><br>"
            + "<h2 style='color:#ffb41e;'>◈ Scoring</h2>"
            + "<table border='0' cellpadding='6'>"
            + "<tr><td style='color:#32cd78;'>[ EASY ]</td><td>100 pts base + 10 × remaining attempts</td></tr>"
            + "<tr><td style='color:#d2a51e;'>[ MEDIUM ]</td><td>200 pts base + 20 × remaining attempts</td></tr>"
            + "<tr><td style='color:#d74b4b;'>[ HARD ]</td><td>300 pts base + 30 × remaining attempts</td></tr>"
            + "</table><br>"
            + "<h2 style='color:#ffb41e;'>◈ The Figure</h2>"
            + "<p>Each wrong guess causes a body part to detach and fall with physics. 6 wrong guesses = game over.</p>"
            + "</body></html>";

        JEditorPane ep = new JEditorPane("text/html", html);
        ep.setEditable(false); ep.setBackground(new Color(8, 11, 22));
        JScrollPane scroll = new JScrollPane(ep);
        scroll.setBorder(new GlowBorder(AMBER_DIM, 1, 4));
        scroll.getViewport().setBackground(new Color(8, 11, 22));
        root.add(scroll, BorderLayout.CENTER);

        JPanel bot = new JPanel(new FlowLayout(FlowLayout.CENTER));
        bot.setOpaque(false); bot.setBorder(BorderFactory.createEmptyBorder(14, 0, 0, 0));
        JButton back = makeGlowButton("← Return to Hub", AMBER_DIM);
        back.addActionListener(e -> cardLayout.show(cardPanel, "MENU"));
        bot.add(back); root.add(bot, BorderLayout.SOUTH);
        return root;
    }

    // ── Leaderboard Screen ────────────────────────────────────────────────────
    private JPanel buildLeaderboardScreen() {
        FuturisticBackground root = new FuturisticBackground();
        root.setLayout(new BorderLayout());
        root.setBorder(BorderFactory.createEmptyBorder(28, 65, 28, 65));

        JLabel title = new JLabel("◈  LEADERBOARD  ◈", SwingConstants.CENTER);
        title.setFont(new Font("Monospaced", Font.BOLD, 28)); title.setForeground(AMBER);
        title.setBorder(BorderFactory.createEmptyBorder(0, 0, 16, 0));
        root.add(title, BorderLayout.NORTH);

        leaderboardListPanel = new JPanel();
        leaderboardListPanel.setLayout(new BoxLayout(leaderboardListPanel, BoxLayout.Y_AXIS));
        leaderboardListPanel.setBackground(new Color(8, 11, 22));
        leaderboardListPanel.setBorder(BorderFactory.createEmptyBorder(12, 22, 12, 22));
        JScrollPane scroll = new JScrollPane(leaderboardListPanel);
        scroll.setBorder(new GlowBorder(AMBER_DIM, 1, 4));
        scroll.getViewport().setBackground(new Color(8, 11, 22));
        root.add(scroll, BorderLayout.CENTER);

        JPanel bot = new JPanel(new FlowLayout(FlowLayout.CENTER, 18, 0));
        bot.setOpaque(false); bot.setBorder(BorderFactory.createEmptyBorder(14, 0, 0, 0));
        JButton backBtn = makeGlowButton("← Return", AMBER_DIM);
        backBtn.addActionListener(e -> cardLayout.show(cardPanel, "MENU"));
        JButton clearBtn = makeGlowButton("✕ Clear Board", RED_DANGER);
        clearBtn.addActionListener(e -> {
            leaderboard.clear();
            if (db.isConnected()) db.clearLeaderboard();
            updateLeaderboardDisplay();
        });
        bot.add(backBtn); bot.add(clearBtn); root.add(bot, BorderLayout.SOUTH);
        return root;
    }

    private void updateLeaderboardDisplay() {
        leaderboardListPanel.removeAll();
        if (db.isConnected()) {
            leaderboard.clear();
            for (DatabaseManager.LeaderboardRow row : db.getTopScores(10))
                leaderboard.add(new LeaderboardEntry(row.name, row.score, row.stage));
        }
        leaderboard.sort((a, b) -> Integer.compare(b.score, a.score));
        if (leaderboard.isEmpty()) {
            JLabel e = new JLabel("[ No entries yet — play to get on the board ]", SwingConstants.CENTER);
            e.setFont(new Font("Monospaced", Font.ITALIC, 14)); e.setForeground(TEXT_MID);
            e.setAlignmentX(CENTER_ALIGNMENT);
            leaderboardListPanel.add(Box.createVerticalStrut(50)); leaderboardListPanel.add(e);
        } else {
            JPanel header = new JPanel(new GridLayout(1, 4, 10, 0));
            header.setBackground(new Color(12, 16, 30)); header.setMaximumSize(new Dimension(620, 36));
            header.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createMatteBorder(0, 0, 1, 0, new Color(AMBER.getRed(), AMBER.getGreen(), AMBER.getBlue(), 80)),
                BorderFactory.createEmptyBorder(6, 4, 6, 4)));
            for (String h : new String[]{"Rank","Player","Score","Stage"}) {
                JLabel lbl = new JLabel(h, SwingConstants.CENTER);
                lbl.setFont(new Font("Monospaced", Font.BOLD, 13)); lbl.setForeground(AMBER);
                header.add(lbl);
            }
            leaderboardListPanel.add(header); leaderboardListPanel.add(Box.createVerticalStrut(4));
            int rank = 1;
            for (LeaderboardEntry entry : leaderboard) {
                if (rank > 10) break;
                JPanel row = new JPanel(new GridLayout(1, 4, 10, 0));
                row.setBackground(rank % 2 == 0 ? new Color(10, 13, 26) : new Color(13, 16, 30));
                row.setMaximumSize(new Dimension(620, 36));
                row.setBorder(BorderFactory.createEmptyBorder(6, 4, 6, 4));
                Color rc = rank == 1 ? AMBER : rank == 2 ? new Color(180, 185, 200)
                         : rank == 3 ? new Color(205, 127, 50) : TEXT_MID;
                for (String val : new String[]{"#" + rank, entry.name, String.valueOf(entry.score), String.valueOf(entry.stage)}) {
                    JLabel lbl = new JLabel(val, SwingConstants.CENTER);
                    lbl.setFont(new Font("Monospaced", Font.BOLD, 13)); lbl.setForeground(rc);
                    row.add(lbl);
                }
                leaderboardListPanel.add(row); leaderboardListPanel.add(Box.createVerticalStrut(2));
                rank++;
            }
        }
        leaderboardListPanel.revalidate(); leaderboardListPanel.repaint();
    }

    // ── Game Screen ───────────────────────────────────────────────────────────
    private JPanel buildGameScreen() {
        JPanel root = new JPanel(new BorderLayout()) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(BG_VOID); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.setStroke(new BasicStroke(0.5f));
                int hexR = 32;
                for (int row = -1; row < getHeight()/(hexR*3/2)+2; row++) {
                    for (int col = -1; col < getWidth()/(int)(hexR*Math.sqrt(3))+2; col++) {
                        int cx = col*(int)(hexR*Math.sqrt(3)) + (row%2==1?(int)(hexR*Math.sqrt(3)/2):0);
                        int cy = row*(hexR*3/2);
                        g2.setColor(new Color(30, 50, 90, 12));
                        int[] xs=new int[6],ys=new int[6];
                        for(int i=0;i<6;i++){double a=Math.PI/180.0*(60*i-30);xs[i]=cx+(int)(hexR*Math.cos(a));ys[i]=cy+(int)(hexR*Math.sin(a));}
                        g2.drawPolygon(xs, ys, 6);
                    }
                }
                RadialGradientPaint gbl = new RadialGradientPaint(new Point2D.Float(0, getHeight()),
                    getHeight()*0.7f, new float[]{0f,1f},
                    new Color[]{new Color(180,90,0,35), new Color(0,0,0,0)});
                g2.setPaint(gbl); g2.fillRect(0, 0, getWidth(), getHeight());
                g2.dispose();
                super.paintComponent(g);
            }
        };
        root.setOpaque(false);

        JPanel topBar = new JPanel(new BorderLayout()) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(6, 9, 18, 230)); g2.fillRect(0, 0, getWidth(), getHeight());
                GradientPaint sep = new GradientPaint(0, getHeight()-1, AMBER_DIM,
                    getWidth(), getHeight()-1, new Color(AMBER_DIM.getRed(), AMBER_DIM.getGreen(), AMBER_DIM.getBlue(), 30));
                g2.setPaint(sep); g2.setStroke(new BasicStroke(1f)); g2.drawLine(0, getHeight()-1, getWidth(), getHeight()-1);
                g2.dispose();
            }
        };
        topBar.setOpaque(false);
        topBar.setBorder(BorderFactory.createEmptyBorder(10, 18, 10, 18));

        JButton backBtn = makeGlowButton("← Skill Tree", AMBER_DIM);
        backBtn.addActionListener(e -> {
            sessionScoreLabel.setText("[ Session Score: " + sessionScore + "  ·  Stage: " + currentStage + " ]");
            updateLevelSelectScreen(); cardLayout.show(cardPanel, "LEVELSELECT");
        });
        topBar.add(backBtn, BorderLayout.WEST);

        JPanel titleGroup = makeTransparentPanel();
        titleGroup.setLayout(new BoxLayout(titleGroup, BoxLayout.Y_AXIS));
        JLabel gTitle = new JLabel("⬡ LexiGuess", SwingConstants.CENTER);
        gTitle.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 24)); gTitle.setForeground(AMBER);
        gTitle.setAlignmentX(CENTER_ALIGNMENT);
        difficultyLabel = new JLabel("", SwingConstants.CENTER);
        difficultyLabel.setFont(new Font("Monospaced", Font.PLAIN, 11));
        difficultyLabel.setForeground(AMBER_DIM); difficultyLabel.setAlignmentX(CENTER_ALIGNMENT);
        titleGroup.add(gTitle); titleGroup.add(difficultyLabel);
        topBar.add(titleGroup, BorderLayout.CENTER);

        JPanel scorePanel = makeTransparentPanel();
        scorePanel.setLayout(new BoxLayout(scorePanel, BoxLayout.Y_AXIS));
        inGameScoreLabel = new JLabel("[ Score: 0 ]", SwingConstants.RIGHT);
        inGameScoreLabel.setFont(new Font("Monospaced", Font.BOLD, 14)); inGameScoreLabel.setForeground(AMBER);
        inGameScoreLabel.setAlignmentX(RIGHT_ALIGNMENT);
        stageLabel = new JLabel("Stage: 1", SwingConstants.RIGHT);
        stageLabel.setFont(new Font("Monospaced", Font.PLAIN, 11)); stageLabel.setForeground(AMBER_DIM);
        stageLabel.setAlignmentX(RIGHT_ALIGNMENT);
        scorePanel.add(inGameScoreLabel); scorePanel.add(stageLabel);
        topBar.add(scorePanel, BorderLayout.EAST);
        root.add(topBar, BorderLayout.NORTH);

        JPanel center = makeTransparentPanel();
        center.setLayout(new GridBagLayout());
        center.setBorder(BorderFactory.createEmptyBorder(14, 20, 10, 20));
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(0, 18, 0, 18);
        gbc.anchor = GridBagConstraints.NORTH;

        hangmanPanel = new HangmanPanel();
        hangmanPanel.setPreferredSize(new Dimension(220, 300));
        gbc.gridx = 0; gbc.gridy = 0; center.add(hangmanPanel, gbc);

        gridPanel = makeTransparentPanel();
        gbc.gridx = 1; gbc.gridy = 0; center.add(gridPanel, gbc);
        root.add(center, BorderLayout.CENTER);

        JPanel bottom = new JPanel() {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setColor(new Color(5, 7, 16, 220)); g2.fillRect(0, 0, getWidth(), getHeight());
                GradientPaint sep = new GradientPaint(0, 0, AMBER_DIM, getWidth(), 0,
                    new Color(AMBER_DIM.getRed(), AMBER_DIM.getGreen(), AMBER_DIM.getBlue(), 20));
                g2.setPaint(sep); g2.drawLine(0, 0, getWidth(), 0);
                g2.dispose();
            }
        };
        bottom.setOpaque(false);
        bottom.setLayout(new BoxLayout(bottom, BoxLayout.Y_AXIS));
        bottom.setBorder(BorderFactory.createEmptyBorder(10, 20, 12, 20));

        clueLabel = new JLabel(" ", SwingConstants.CENTER);
        clueLabel.setFont(new Font("Monospaced", Font.ITALIC, 13)); clueLabel.setForeground(CLUE_CLR);
        clueLabel.setAlignmentX(CENTER_ALIGNMENT);
        bottom.add(clueLabel); bottom.add(Box.createVerticalStrut(2));

        messageLabel = new JLabel(" ", SwingConstants.CENTER);
        messageLabel.setFont(new Font("Monospaced", Font.PLAIN, 13)); messageLabel.setForeground(TEXT_BRIGHT);
        messageLabel.setAlignmentX(CENTER_ALIGNMENT);
        bottom.add(messageLabel); bottom.add(Box.createVerticalStrut(8));

        JPanel inputRow = new JPanel(new FlowLayout(FlowLayout.CENTER, 12, 0));
        inputRow.setOpaque(false);

        inputField = new JTextField(10) {
            @Override protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.setColor(new Color(10, 14, 28)); g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                g2.setColor(new Color(AMBER.getRed(), AMBER.getGreen(), AMBER.getBlue(), 80));
                g2.setStroke(new BasicStroke(1.2f)); g2.drawRoundRect(0, 0, getWidth()-1, getHeight()-1, 8, 8);
                g2.dispose();
                super.paintComponent(g);
            }
        };
        inputField.setFont(new Font("Monospaced", Font.BOLD, 20));
        inputField.setForeground(TEXT_BRIGHT); inputField.setOpaque(false);
        inputField.setBackground(new Color(0,0,0,0)); inputField.setCaretColor(AMBER);
        inputField.setHorizontalAlignment(SwingConstants.CENTER);
        inputField.setBorder(BorderFactory.createEmptyBorder(7, 10, 7, 10));
        inputField.setPreferredSize(new Dimension(215, 46));
        inputField.addKeyListener(new KeyAdapter() {
            public void keyTyped(KeyEvent e) {
                char c = e.getKeyChar();
                if (!Character.isLetter(c)) { e.consume(); return; }
                if (inputField.getText().length() >= wordLength) e.consume();
                else { e.setKeyChar(Character.toUpperCase(c)); playSound(SOUND_KEYCLICK); }
            }
            public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_ENTER) submitGuess(); }
        });

        submitBtn = makeGlowButton("GUESS  →", EASY_CLR);
        submitBtn.setFont(new Font("Monospaced", Font.BOLD, 13));
        submitBtn.setPreferredSize(new Dimension(120, 46));
        submitBtn.addActionListener(e -> submitGuess());

        JButton newWordBtn = makeGlowButton("New Word", AMBER_DIM);
        newWordBtn.setPreferredSize(new Dimension(110, 46));
        newWordBtn.addActionListener(e -> startGame());

        inputRow.add(inputField); inputRow.add(submitBtn); inputRow.add(newWordBtn);
        bottom.add(inputRow); bottom.add(Box.createVerticalStrut(10));

        keyboardPanel = makeTransparentPanel();
        buildKeyboard();
        bottom.add(keyboardPanel);
        root.add(bottom, BorderLayout.SOUTH);
        return root;
    }

    // ── Keyboard ──────────────────────────────────────────────────────────────
    private void buildKeyboard() {
        keyboardPanel.removeAll();
        keyboardPanel.setLayout(new BoxLayout(keyboardPanel, BoxLayout.Y_AXIS));
        keyLabels.clear();
        for (String row : new String[]{"QWERTYUIOP","ASDFGHJKL","ZXCVBNM"}) {
            JPanel rowP = new JPanel(new FlowLayout(FlowLayout.CENTER, 4, 2));
            rowP.setOpaque(false);
            for (char ch : row.toCharArray()) {
                JLabel k = new JLabel(String.valueOf(ch), SwingConstants.CENTER) {
                    @Override protected void paintComponent(Graphics g) {
                        Graphics2D g2 = (Graphics2D) g.create();
                        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                        g2.setColor(getBackground()); g2.fillRoundRect(0, 0, getWidth(), getHeight(), 5, 5);
                        g2.setColor(new Color(50, 55, 80, 160)); g2.setStroke(new BasicStroke(0.8f));
                        g2.drawRoundRect(0, 0, getWidth()-1, getHeight()-1, 5, 5);
                        g2.dispose(); super.paintComponent(g);
                    }
                };
                k.setFont(new Font("Monospaced", Font.BOLD, 11));
                k.setForeground(TEXT_BRIGHT); k.setBackground(new Color(18, 22, 38));
                k.setOpaque(false); k.setPreferredSize(new Dimension(30, 28));
                keyLabels.put(ch, k); rowP.add(k);
            }
            keyboardPanel.add(rowP);
        }
    }

    private void updateKeyboard() {
        for (Map.Entry<Character, JLabel> e : keyLabels.entrySet()) {
            char ch = e.getKey(); JLabel lbl = e.getValue();
            if      (correctLetters.contains(ch)) { lbl.setBackground(GREEN_CORRECT);  lbl.setForeground(new Color(220,255,235)); }
            else if (presentLetters.contains(ch)) { lbl.setBackground(YELLOW_PRESENT); lbl.setForeground(new Color(255,240,200)); }
            else if (absentLetters.contains(ch))  { lbl.setBackground(GRAY_ABSENT);    lbl.setForeground(TEXT_DIM); }
        }
        keyboardPanel.repaint();
    }

    // ── Game Logic ────────────────────────────────────────────────────────────
    private void startGame() {
        List<WordEntry> bank = difficulty.equals("EASY") ? easyWords
                             : difficulty.equals("MEDIUM") ? mediumWords : hardWords;
        if (bank.isEmpty()) {
            JOptionPane.showMessageDialog(this, "No words for difficulty: " + difficulty, "Empty", JOptionPane.WARNING_MESSAGE);
            return;
        }
        totalLevels = bank.size();
        if (currentLevel < 1) currentLevel = 1;
        if (currentLevel > totalLevels) currentLevel = totalLevels;
        currentEntry = bank.get(currentLevel - 1);
        targetWord = currentEntry.word; currentClue = currentEntry.clue;
        wordLength = targetWord.length();

        guesses.clear(); feedbackList.clear();
        correctLetters.clear(); presentLetters.clear(); absentLetters.clear();
        currentAttempt = 0; gameOver = false; gameWon = false;

        buildGrid(); buildKeyboard();
        hangmanPanel.resetGame();
        hangmanPanel.repaint();

        Color dc = difficulty.equals("EASY") ? EASY_CLR : difficulty.equals("MEDIUM") ? MEDIUM_CLR : HARD_CLR;
        difficultyLabel.setForeground(dc);
        difficultyLabel.setText("[ " + difficulty + " ]  ·  Level " + currentLevel + " of " + totalLevels + "  ·  " + wordLength + "-letter word");
        clueLabel.setText("// clue:  " + currentClue);
        messageLabel.setText("Decipher the hidden programming word...");
        messageLabel.setForeground(TEXT_MID);
        inGameScoreLabel.setText("[ Score: " + sessionScore + " ]");
        stageLabel.setText("Stage: " + currentStage + "  ·  Lv." + currentLevel + "/" + totalLevels);
        inputField.setText(""); inputField.setEnabled(true); submitBtn.setEnabled(true);
        cardLayout.show(cardPanel, "GAME");
        inputField.requestFocus();
    }

    private void buildGrid() {
        gridPanel.removeAll();
        int tileSize = wordLength <= 5 ? 60 : wordLength == 6 ? 54 : wordLength <= 8 ? 48 : 42;
        gridPanel.setLayout(new GridLayout(maxAttempts, wordLength, 6, 6));
        tiles = new JLabel[maxAttempts][wordLength];
        for (int r = 0; r < maxAttempts; r++) {
            for (int c = 0; c < wordLength; c++) {
                JLabel tile = new JLabel("", SwingConstants.CENTER) {
                    @Override protected void paintComponent(Graphics g) {
                        Graphics2D g2 = (Graphics2D) g.create();
                        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                        g2.setColor(getBackground()); g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                        Color bg = getBackground();
                        if (!bg.equals(TILE_EMPTY_BG)) {
                            g2.setColor(new Color(Math.min(255, bg.getRed()+40),
                                Math.min(255, bg.getGreen()+40), Math.min(255, bg.getBlue()+40), 140));
                        } else {
                            g2.setColor(TILE_EMPTY_BD);
                        }
                        g2.setStroke(new BasicStroke(1.2f));
                        g2.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 8, 8);
                        g2.dispose();
                        super.paintComponent(g);
                    }
                };
                tile.setFont(new Font("Monospaced", Font.BOLD, tileSize - 22));
                tile.setForeground(TEXT_BRIGHT); tile.setBackground(TILE_EMPTY_BG);
                tile.setOpaque(false); tile.setBorder(BorderFactory.createEmptyBorder());
                tile.setPreferredSize(new Dimension(tileSize, tileSize));
                tiles[r][c] = tile; gridPanel.add(tile);
            }
        }
        gridPanel.revalidate(); gridPanel.repaint();
    }

    private void submitGuess() {
        if (gameOver || gameWon) return;
        String guess = inputField.getText().trim().toUpperCase();
        if (guess.length() != wordLength) {
            messageLabel.setText("// ERROR: word must be exactly " + wordLength + " letters");
            messageLabel.setForeground(MEDIUM_CLR); return;
        }
        int[] fb = computeFeedback(guess, targetWord);
        guesses.add(guess); feedbackList.add(fb);

        for (int c = 0; c < wordLength; c++) {
            JLabel tile = tiles[currentAttempt][c];
            tile.setText(String.valueOf(guess.charAt(c))); tile.setBorder(BorderFactory.createEmptyBorder());
            if      (fb[c] == 2) { tile.setBackground(GREEN_CORRECT);  correctLetters.add(guess.charAt(c)); }
            else if (fb[c] == 1) { tile.setBackground(YELLOW_PRESENT); presentLetters.add(guess.charAt(c)); }
            else                 { tile.setBackground(GRAY_ABSENT);     absentLetters.add(guess.charAt(c)); }
            tile.repaint();
        }
        currentAttempt++;
        updateKeyboard();

        boolean allCorrect = true;
        for (int f : fb) if (f != 2) { allCorrect = false; break; }
        if (!allCorrect) hangmanPanel.addWrongGuess();
        hangmanPanel.repaint();

        if (allCorrect) {
            gameWon = true; playSound(SOUND_CORRECT);
            int remaining = maxAttempts - currentAttempt;
            int base  = difficulty.equals("EASY") ? 100 : difficulty.equals("MEDIUM") ? 200 : 300;
            int bonus = difficulty.equals("EASY") ?  10 : difficulty.equals("MEDIUM") ?  20 :  30;
            int roundScore = base + remaining * bonus;
            sessionScore += roundScore; currentStage++;

            int nextLevel = currentLevel + 1;
            int prevHighest = difficultyProgress.getOrDefault(difficulty, 1);
            if (nextLevel > prevHighest && nextLevel <= totalLevels) difficultyProgress.put(difficulty, nextLevel);
            if (db.isConnected()) db.saveProgress(currentPlayerName, difficulty, difficultyProgress.get(difficulty));
            if (currentLevel == totalLevels) difficultyProgress.put(difficulty, totalLevels + 1);
            currentLevel = nextLevel;

            messageLabel.setText("// COMPILE SUCCESS  ·  +" + roundScore + " pts");
            messageLabel.setForeground(AMBER);
            inGameScoreLabel.setText("[ Score: " + sessionScore + " ]");
            stageLabel.setText("Stage: " + currentStage);
            sessionScoreLabel.setText("[ Session Score: " + sessionScore + "  ·  Stage: " + currentStage + " ]");
            inputField.setEnabled(false); submitBtn.setEnabled(false);
            addToLeaderboard(currentPlayerName, sessionScore, currentStage);
            SwingUtilities.invokeLater(() -> showEndGameDialog(
                "✦ COMPILE SUCCESS ✦", "You cracked the word:", targetWord,
                "+" + roundScore + " pts  ·  Total: " + sessionScore, GREEN_CORRECT, "Next Level →"));

        } else if (currentAttempt >= maxAttempts) {
            gameOver = true; playSound(SOUND_LOSE);
            messageLabel.setText("// RUNTIME ERROR — The word was: " + targetWord + " — Score reset");
            messageLabel.setForeground(RED_DANGER);
            if (sessionScore > 0) addToLeaderboard(currentPlayerName, sessionScore, currentStage);
            sessionScore = 0;
            inGameScoreLabel.setText("[ Score: 0 ]");
            sessionScoreLabel.setText("[ Session Score: 0  ·  Stage: " + currentStage + " ]");
            inputField.setEnabled(false); submitBtn.setEnabled(false);
            SwingUtilities.invokeLater(() -> showEndGameDialog(
                "RUNTIME ERROR", "The word was:", targetWord,
                "Your score has been reset.", RED_DANGER, "Retry"));
        } else {
            int left = maxAttempts - currentAttempt;
            messageLabel.setText("// Attempt " + currentAttempt + " / " + maxAttempts + "  ·  " + left + " remaining");
            messageLabel.setForeground(TEXT_MID);
        }
        inputField.setText(""); gridPanel.repaint();
    }

    private void addToLeaderboard(String name, int sc, int stage) {
        boolean found = false;
        for (LeaderboardEntry e : leaderboard) {
            if (e.name.equals(name)) { if (sc > e.score) { e.score = sc; e.stage = stage; } found = true; break; }
        }
        if (!found) leaderboard.add(new LeaderboardEntry(name, sc, stage));
        if (db.isConnected()) db.saveScore(name, sc, stage);
    }

    private int[] computeFeedback(String guess, String target) {
        int len = target.length();
        int[] result = new int[len];
        boolean[] tUsed = new boolean[len], gUsed = new boolean[len];
        for (int i = 0; i < len; i++)
            if (guess.charAt(i) == target.charAt(i)) { result[i] = 2; tUsed[i] = gUsed[i] = true; }
        for (int i = 0; i < len; i++) {
            if (gUsed[i]) continue;
            for (int j = 0; j < len; j++) {
                if (tUsed[j]) continue;
                if (guess.charAt(i) == target.charAt(j)) { result[i] = 1; tUsed[j] = true; break; }
            }
        }
        return result;
    }

    // ── Leaderboard Entry ─────────────────────────────────────────────────────
    static class LeaderboardEntry {
        String name; int score, stage;
        LeaderboardEntry(String n, int s, int st) { name=n; score=s; stage=st; }
    }

    // ══════════════════════════════════════════════════════════════════════════
    //  HANGMAN PANEL  —  physics-based figure with coloured clothes
    //  Ported from lexiguess_hangman_reordered.html
    //
    //  ┌─────────────────────────────────────────────────────────────────────┐
    //  │  BACKGROUND IMAGE PLACEHOLDER                                       │
    //  │  To use a custom background inside the hangman box:                 │
    //  │  1. Place your image file next to LexiGuess.java                    │
    //  │  2. Set HANGMAN_BG_IMAGE to the filename, e.g. "my_bg.png"          │
    //  │     Supported formats: PNG, JPG, GIF, BMP                           │
    //  │  3. Leave it as "" to use the default dark grid background          │
    //  └─────────────────────────────────────────────────────────────────────┘
    // ══════════════════════════════════════════════════════════════════════════
    class HangmanPanel extends JPanel {

        // ── ▼▼▼  SET YOUR BACKGROUND IMAGE FILENAME HERE  ▼▼▼ ──────────────
        private static final String HANGMAN_BG_IMAGE = "brickwall.jpg";   // e.g. "brickwall.png"
        // ── ▲▲▲──────────────────────────────────────────────────────────────

        // Figure colours — matching the HTML palette
        private static final int C_WOOD_D  = 0xFF4a3018;
        private static final int C_WOOD    = 0xFF6b4c2a;
        private static final int C_ROPE    = 0xFFc8a060;
        private static final int C_SKIN    = 0xFFe8c89a;
        private static final int C_SKIN_S  = 0xFFc8a070;
        private static final int C_SHIRT   = 0xFF3a4a6a;
        private static final int C_SHIRT_S = 0xFF2a3a5a;
        private static final int C_PANTS   = 0xFF2a2a3a;
        private static final int C_PANTS_S = 0xFF1a1a2a;
        private static final int C_SHOE    = 0xFF1a1210;
        private static final int C_HAIR    = 0xFF2a1a08;

        // Part order: index 0 = first to fall on 1st wrong guess
        private static final String[] PART_ORDER = {"lLeg","rLeg","lArm","rArm","torso","head"};
        private static final int MAX_WRONG = 6;

        // Per-piece physics state
        private final double[] px    = new double[MAX_WRONG];
        private final double[] py    = new double[MAX_WRONG];
        private final double[] pvx   = new double[MAX_WRONG];
        private final double[] pvy   = new double[MAX_WRONG];
        private final double[] pAngle= new double[MAX_WRONG];
        private final double[] pVa   = new double[MAX_WRONG];
        private final boolean[] attached = new boolean[MAX_WRONG];
        private final boolean[] landed   = new boolean[MAX_WRONG];

        private int wrongCount   = 0;
        private double swingT    = 0.0;
        private Timer physicsTimer;

        // Background image (loaded once)
        private Image bgImage = null;

        // Physics constants
        private static final double GRAVITY   = 0.55;
        private static final double BOUNCE    = 0.28;
        private static final double FRICTION  = 0.84;
        private static final double ANG_DAMP  = 0.78;

        HangmanPanel() {
            setOpaque(true);
            setBackground(BG_SURFACE);
            setBorder(new GlowBorder(AMBER_DIM, 1, 10));
            resetPieces();
            loadBgImage();

            // Continuous swing animation (low CPU — only repaints when no physics running)
            Timer swingTimer = new Timer(40, e -> {
                swingT += 0.04;
                repaint();
            });
            swingTimer.start();
        }

        // ── Load background image ─────────────────────────────────────────────
        private void loadBgImage() {
            if (HANGMAN_BG_IMAGE == null || HANGMAN_BG_IMAGE.isEmpty()) return;
            File f = new File(HANGMAN_BG_IMAGE);
            if (f.exists()) {
                bgImage = new ImageIcon(HANGMAN_BG_IMAGE).getImage();
                return;
            }
            java.net.URL url = getClass().getResource("/" + HANGMAN_BG_IMAGE);
            if (url != null) bgImage = new ImageIcon(url).getImage();
        }

        // ── Geometry helpers ──────────────────────────────────────────────────
        private int cx()       { return getWidth() / 2 + 10; }
        private int groundY()  { return getHeight() - 22; }
        private int ropeEndY() { return 55; }
        private int headR()    { return 18; }
        private int headCY()   { return ropeEndY() + headR(); }
        private int shoulderY(){ return headCY() + headR() + 4; }
        private int hipY()     { return shoulderY() + 54; }  // torsoH = 54
        private int armL()     { return 34; }
        private int legL()     { return 50; }

        // ── Piece initialisation ──────────────────────────────────────────────
        private void resetPieces() {
            int cx = getWidth() > 0 ? cx() : 120;
            for (int i = 0; i < MAX_WRONG; i++) {
                String name = PART_ORDER[i];
                double ox = cx, oy = 0;
                switch (name) {
                    case "head":  oy = headCY();                           break;
                    case "torso": oy = shoulderY() + 27;                   break;
                    case "lArm":  ox = cx - 20; oy = shoulderY() + 17;    break;
                    case "rArm":  ox = cx + 20; oy = shoulderY() + 17;    break;
                    case "lLeg":  ox = cx - 20; oy = hipY() + 25;         break;
                    case "rLeg":  ox = cx + 20; oy = hipY() + 25;         break;
                }
                px[i] = ox; py[i] = oy;
                pvx[i] = 0; pvy[i] = 0; pAngle[i] = 0; pVa[i] = 0;
                attached[i] = true; landed[i] = false;
            }
        }

        // ── Public API called by game logic ───────────────────────────────────
        void resetGame() {
            wrongCount = 0;
            if (physicsTimer != null) physicsTimer.stop();
            resetPieces();
            repaint();
        }

        void addWrongGuess() {
            if (wrongCount >= MAX_WRONG) return;
            detachPiece(wrongCount);
            wrongCount++;
            startPhysics();
        }

        // ── Detach a piece with launch velocity ───────────────────────────────
        private void detachPiece(int idx) {
            attached[idx] = false;
            landed[idx]   = false;
            pvx[idx] = (Math.random() - 0.5) * 6.0;
            pvy[idx] = -3.0 - Math.random() * 4.0;
            pVa[idx] = (Math.random() - 0.5) * 0.25;
        }

        // ── Physics loop ──────────────────────────────────────────────────────
        private void startPhysics() {
            if (physicsTimer != null) physicsTimer.stop();
            physicsTimer = new Timer(16, e -> {
                boolean anyActive = false;
                int floor = groundY() - 12;
                for (int i = 0; i < MAX_WRONG; i++) {
                    if (attached[i] || landed[i]) continue;
                    anyActive = true;
                    pvy[i] += GRAVITY;
                    px[i]  += pvx[i];
                    py[i]  += pvy[i];
                    pAngle[i] += pVa[i];
                    // Floor bounce
                    if (py[i] >= floor) {
                        py[i] = floor;
                        pvy[i] = -Math.abs(pvy[i]) * BOUNCE;
                        pvx[i] *= FRICTION;
                        pVa[i] *= ANG_DAMP;
                        if (Math.abs(pvy[i]) < 0.4 && Math.abs(pvx[i]) < 0.12) {
                            pvy[i] = 0; pvx[i] = 0; pVa[i] = 0; landed[i] = true;
                        }
                    }
                    // Wall bounce
                    if (px[i] < 12)            { px[i] = 12;             pvx[i] =  Math.abs(pvx[i]) * 0.5; }
                    if (px[i] > getWidth()-12) { px[i] = getWidth()-12;  pvx[i] = -Math.abs(pvx[i]) * 0.5; }
                }
                repaint();
                if (!anyActive) ((Timer) e.getSource()).stop();
            });
            physicsTimer.start();
        }

        // ── Swing amount for rope figure ──────────────────────────────────────
        private double getSwing() {
            if (wrongCount == 0 || !attached[MAX_WRONG - 1]) return 0; // head is last in PART_ORDER
            return Math.sin(swingT * 1.4) * 3.0;
        }

        // ══════════════════════════════════════════════════════════════════════
        //  PAINTING
        // ══════════════════════════════════════════════════════════════════════
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2 = (Graphics2D) g.create();
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

            int w = getWidth(), h = getHeight();

            drawBackground(g2, w, h);
            drawShadow(g2);
            drawGallows(g2);

            // Detached pieces (drawn behind the attached figure)
            for (int i = 0; i < MAX_WRONG; i++)
                if (!attached[i]) drawDetached(g2, i);

            drawAttachedFigure(g2);
            g2.dispose();
        }

        // ── Background ────────────────────────────────────────────────────────
        private void drawBackground(Graphics2D g2, int w, int h) {
            if (bgImage != null) {
                int iw = bgImage.getWidth(this), ih = bgImage.getHeight(this);
                if (iw > 0 && ih > 0) {
                    double sc = Math.max((double) w / iw, (double) h / ih);
                    int dw = (int)(iw * sc), dh = (int)(ih * sc);
                    g2.drawImage(bgImage, (w - dw)/2, (h - dh)/2, dw, dh, this);
                    // Darken overlay for readability
                    g2.setColor(new Color(0, 0, 0, 120));
                    g2.fillRect(0, 0, w, h);
                    return;
                }
            }
            // Default dark grid background
            g2.setColor(new Color(13, 16, 24));
            g2.fillRect(0, 0, w, h);
            g2.setColor(new Color(212, 184, 106, 8));
            g2.setStroke(new BasicStroke(0.5f));
            for (int x = 0; x < w; x += 30) { g2.drawLine(x, 0, x, h); }
            for (int y = 0; y < h; y += 30) { g2.drawLine(0, y, w, y); }
        }

        // ── Ground shadow ─────────────────────────────────────────────────────
        private void drawShadow(Graphics2D g2) {
            if (wrongCount == 0) return;
            double sw = getSwing();
            int cx = cx(), gy = groundY();
            g2.setColor(new Color(0, 0, 0, 50));
            g2.fillOval((int)(cx + sw * 2 - 38 + Math.abs(sw)), gy - 10,
                         (int)(76 - Math.abs(sw) * 2), 12);
        }

        // ── Gallows ───────────────────────────────────────────────────────────
        private void drawGallows(Graphics2D g2) {
            int cx = cx(), gy = groundY(), w = getWidth();
            g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);

            // Shadow layer
            g2.setColor(new Color(C_WOOD_D));
            g2.setStroke(new BasicStroke(10f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            g2.drawLine(40, gy, w - 40, gy);
            g2.drawLine(80, gy, 80, 30);
            g2.drawLine(80, 30, cx, 30);

            // Main wood
            g2.setColor(new Color(C_WOOD));
            g2.setStroke(new BasicStroke(7f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            g2.drawLine(40, gy, w - 40, gy);
            g2.drawLine(80, gy, 80, 30);
            g2.drawLine(80, 30, cx, 30);

            // Wood grain
            g2.setColor(new Color(0x5a3c1a));
            g2.setStroke(new BasicStroke(2f));
            for (int y = 30; y < gy; y += 18) g2.drawLine(76, y, 84, y + 6);

            // Brace
            g2.setColor(new Color(0x8a6030));
            g2.setStroke(new BasicStroke(3f));
            g2.drawLine(80, gy - 2, 130, gy - 8);
            g2.drawLine(80, gy,     125, gy + 8);

            // Rope (only when head is still attached — head is index 5)
            if (attached[5]) {
                g2.setColor(new Color(0xa08040));
                g2.setStroke(new BasicStroke(4f));
                g2.drawLine(cx, 30, cx, ropeEndY());
                g2.setColor(new Color(C_ROPE));
                g2.setStroke(new BasicStroke(2f));
                g2.drawLine(cx - 2, 30, cx - 2, ropeEndY());
                // Rope twist detail
                g2.setColor(new Color(0xa08040));
                g2.setStroke(new BasicStroke(1.5f));
                for (int i = 0; i < 4; i++)
                    g2.drawLine(cx - 3, 30 + i * 7, cx + 5, 30 + i * 7 + 4);
            }
        }

        // ── Full attached figure (swings as a unit) ───────────────────────────
        private void drawAttachedFigure(Graphics2D g2) {
            boolean anyAttached = false;
            for (boolean a : attached) if (a) { anyAttached = true; break; }
            if (!anyAttached) return;

            int cx = cx();
            double sw = getSwing();
            double rad = sw * Math.PI / 180.0;

            Graphics2D g3 = (Graphics2D) g2.create();
            g3.translate(cx, ropeEndY());
            g3.rotate(rad);
            g3.translate(-cx, -ropeEndY());

            if (attached[0]) drawLegA(g3, cx, hipY(), -1); // lLeg
            if (attached[1]) drawLegA(g3, cx, hipY(),  1); // rLeg
            if (attached[2]) drawArmA(g3, cx, shoulderY(), -1); // lArm
            if (attached[3]) drawArmA(g3, cx, shoulderY(),  1); // rArm
            if (attached[4]) drawTorsoA(g3, cx);                // torso
            if (attached[5]) drawHeadA(g3, cx, wrongCount >= MAX_WRONG); // head

            g3.dispose();
        }

        // ── Head ──────────────────────────────────────────────────────────────
        private void drawHeadA(Graphics2D g2, int cx, boolean dead) {
            int cy = headCY(), r = headR();
            g2.setColor(new Color(C_SKIN));
            g2.fillOval(cx - r, cy - r, r * 2, r * 2);
            g2.setColor(new Color(C_SKIN_S));
            g2.setStroke(new BasicStroke(2f));
            g2.drawOval(cx - r, cy - r, r * 2, r * 2);
            // Hair
            g2.setColor(new Color(C_HAIR));
            drawEllipseA(g2, cx, cy - r + 4, (int)(r * 0.85), (int)(r * 0.48));
            g2.fillOval(cx - r + 1, cy - 9, 10, 10);
            g2.fillOval(cx + r - 11, cy - 9, 10, 10);
            if (dead) {
                // X eyes
                g2.setColor(new Color(C_HAIR));
                g2.setStroke(new BasicStroke(2f));
                g2.drawLine(cx - 7, cy - 5, cx - 3, cy - 1);
                g2.drawLine(cx - 3, cy - 5, cx - 7, cy - 1);
                g2.drawLine(cx + 3, cy - 5, cx + 7, cy - 1);
                g2.drawLine(cx + 7, cy - 5, cx + 3, cy - 1);
                // Grimace
                g2.drawLine(cx - 4, cy + 7, cx + 4, cy + 4);
            } else {
                // Eyes
                g2.setColor(new Color(C_HAIR));
                drawEllipseA(g2, cx - 6, cy - 2, 3, 4);
                drawEllipseA(g2, cx + 6, cy - 2, 3, 4);
                g2.setColor(Color.WHITE);
                g2.fillOval(cx - 6, cy - 4, 3, 3);
                g2.fillOval(cx + 5, cy - 4, 3, 3);
                // Smile
                g2.setColor(new Color(C_HAIR));
                g2.setStroke(new BasicStroke(1.5f));
                g2.drawArc(cx - 5, cy + 1, 10, 10, 0, -180);
                // Cheeks
                g2.setColor(new Color(232, 136, 136, 100));
                g2.fillOval(cx - 13, cy, 8, 6);
                g2.fillOval(cx + 5,  cy, 8, 6);
            }
        }

        private void drawEllipseA(Graphics2D g2, int cx, int cy, int rx, int ry) {
            g2.fillOval(cx - rx, cy - ry, rx * 2, ry * 2);
        }

        // ── Torso ─────────────────────────────────────────────────────────────
        private void drawTorsoA(Graphics2D g2, int cx) {
            int sy = shoulderY(), hy = hipY();
            // Shadow layer
            g2.setColor(new Color(C_SHIRT_S));
            int[] xs = {cx-14, cx+14, cx+12, cx-12};
            int[] ys = {sy, sy, hy, hy};
            g2.fillPolygon(xs, ys, 4);
            // Main shirt
            g2.setColor(new Color(C_SHIRT));
            int[] xs2 = {cx-13, cx+13, cx+11, cx-11};
            int[] ys2 = {sy+2, sy+2, hy-2, hy-2};
            g2.fillPolygon(xs2, ys2, 4);
            // Horizontal stripes
            g2.setColor(new Color(0x4a5a7a));
            g2.setStroke(new BasicStroke(1f));
            for (int y = sy + 12; y < hy - 6; y += 14)
                g2.drawLine(cx - 10, y, cx + 10, y);
        }

        // ── Arm ───────────────────────────────────────────────────────────────
        private void drawArmA(Graphics2D g2, int cx, int sy, int dir) {
            double sway = Math.sin(swingT * 2.1 + dir * 0.8) * 5.0;
            int aL = armL();
            int ex = (int)(cx + dir * (aL * 0.55 + sway * 0.3)), ey = sy + 20;
            int hx = (int)(cx + dir * (aL + sway));
            int hy = (int)(sy + aL * 0.9 + Math.cos(swingT * 1.8) * 3);
            // Shadow
            g2.setColor(new Color(C_SHIRT_S));
            g2.setStroke(new BasicStroke(8f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            drawQuadCurve(g2, cx + dir * 10, sy + 4, ex, ey, hx, hy);
            // Sleeve
            g2.setColor(new Color(C_SHIRT));
            g2.setStroke(new BasicStroke(6f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            drawQuadCurve(g2, cx + dir * 10, sy + 4, ex, ey, hx, hy);
            // Hand
            g2.setColor(new Color(C_SKIN));
            g2.fillOval(hx - 5, hy - 5, 10, 10);
        }

        // ── Leg ───────────────────────────────────────────────────────────────
        private void drawLegA(Graphics2D g2, int cx, int hy2, int dir) {
            double sway = Math.sin(swingT * 1.6 + dir * 1.2) * 4.0;
            int lL = legL();
            int kx = (int)(cx + dir * (16 + Math.abs(sway) * 0.3)), ky = hy2 + lL / 2;
            int fx = (int)(cx + dir * (22 + sway)),                  fy = hy2 + lL;
            // Shadow
            g2.setColor(new Color(C_PANTS_S));
            g2.setStroke(new BasicStroke(10f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            drawQuadCurve(g2, cx + dir * 8, hy2, kx, ky, fx, fy);
            // Pants
            g2.setColor(new Color(C_PANTS));
            g2.setStroke(new BasicStroke(8f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            drawQuadCurve(g2, cx + dir * 8, hy2, kx, ky, fx, fy);
            // Shoe
            g2.setColor(new Color(C_SHOE));
            drawShoe(g2, fx + dir * 7, fy + 2, dir);
        }

        private void drawShoe(Graphics2D g2, int cx, int cy, int dir) {
            int[] xs = new int[8], ys = new int[8];
            // Simple ellipse-like shoe shape
            for (int i = 0; i < 8; i++) {
                double a = Math.PI * i / 7.0;
                xs[i] = cx + (int)(12 * Math.cos(a) * dir);
                ys[i] = cy + (int)(5  * Math.sin(a));
            }
            g2.fillPolygon(xs, ys, 8);
        }

        private void drawQuadCurve(Graphics2D g2, int x1, int y1, int cx, int cy, int x2, int y2) {
            java.awt.geom.QuadCurve2D qc = new java.awt.geom.QuadCurve2D.Float(x1, y1, cx, cy, x2, y2);
            g2.draw(qc);
        }

        // ── Detached piece (tumbling) ─────────────────────────────────────────
        private void drawDetached(Graphics2D g2, int idx) {
            String name = PART_ORDER[idx];
            Graphics2D g3 = (Graphics2D) g2.create();
            g3.translate((int) px[idx], (int) py[idx]);
            g3.rotate(pAngle[idx]);

            int aL = armL(), lL = legL(), hR = headR(), tH = 54;

            switch (name) {
                case "head": {
                    g3.setColor(new Color(C_SKIN));
                    g3.fillOval(-hR, -hR, hR * 2, hR * 2);
                    g3.setColor(new Color(C_SKIN_S));
                    g3.setStroke(new BasicStroke(2f));
                    g3.drawOval(-hR, -hR, hR * 2, hR * 2);
                    g3.setColor(new Color(C_HAIR));
                    g3.fillOval(-hR + 1, -hR - 4, hR * 2 - 2, hR);
                    g3.fillOval(-hR + 1, -9, 10, 10);
                    g3.fillOval(hR - 11,  -9, 10, 10);
                    // X eyes (dead)
                    g3.setStroke(new BasicStroke(2f));
                    g3.drawLine(-7, -5, -3, -1);
                    g3.drawLine(-3, -5, -7, -1);
                    g3.drawLine( 3, -5,  7, -1);
                    g3.drawLine( 7, -5,  3, -1);
                    g3.drawLine(-4,  7,  4,  4);
                    break;
                }
                case "torso": {
                    g3.setColor(new Color(C_SHIRT_S));
                    int[] xs = {-14, 14, 12, -12};
                    int[] ys = {-tH/2, -tH/2, tH/2, tH/2};
                    g3.fillPolygon(xs, ys, 4);
                    g3.setColor(new Color(C_SHIRT));
                    int[] xs2 = {-13, 13, 11, -11};
                    int[] ys2 = {-tH/2+2, -tH/2+2, tH/2-2, tH/2-2};
                    g3.fillPolygon(xs2, ys2, 4);
                    break;
                }
                case "lArm":
                case "rArm": {
                    int dir = name.equals("lArm") ? -1 : 1;
                    g3.setColor(new Color(C_SHIRT_S));
                    g3.setStroke(new BasicStroke(8f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                    g3.drawLine(0, 0, (int)(dir * aL * 0.8), (int)(aL * 0.7));
                    g3.setColor(new Color(C_SHIRT));
                    g3.setStroke(new BasicStroke(6f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                    g3.drawLine(0, 0, (int)(dir * aL * 0.8), (int)(aL * 0.7));
                    g3.setColor(new Color(C_SKIN));
                    g3.fillOval((int)(dir * aL * 0.8) - 5, (int)(aL * 0.7) - 5, 10, 10);
                    break;
                }
                case "lLeg":
                case "rLeg": {
                    int dir = name.equals("lLeg") ? -1 : 1;
                    g3.setColor(new Color(C_PANTS_S));
                    g3.setStroke(new BasicStroke(10f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                    g3.drawLine(0, -lL/2, dir * 14, lL/2);
                    g3.setColor(new Color(C_PANTS));
                    g3.setStroke(new BasicStroke(8f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                    g3.drawLine(0, -lL/2, dir * 14, lL/2);
                    g3.setColor(new Color(C_SHOE));
                    drawShoe(g3, dir * 20, lL/2 + 2, dir);
                    break;
                }
            }
            g3.dispose();
        }
    }
    // ── end HangmanPanel ──────────────────────────────────────────────────────

    public static void main(String[] args) {
        SwingUtilities.invokeLater(LexiGuess::new);
    }
}