Van idee.
naar Eindresultaat.

import pygame
import sys
import time
import json
import os
import RPi.GPIO as GPIO

# === GPIO Setup ===
BUTTON_PIN = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# === Scorebord Bestandsnaam ===
SCORE_FILE = "scores.json"

# === Laad scorebord ===
def load_scores():
    if os.path.exists(SCORE_FILE):
        with open(SCORE_FILE, "r") as f:
            return json.load(f)
    return {}

def save_scores(scores):
    with open(SCORE_FILE, "w") as f:
        json.dump(scores, f, indent=4)

scoreboard = load_scores()

# === Pygame Setup ===
pygame.init()
WIDTH, HEIGHT = 800, 480
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("10 Seconden Timer")

font_big = pygame.font.SysFont(None, 150)
font_med = pygame.font.SysFont(None, 80)
font_small = pygame.font.SysFont(None, 40)

clock = pygame.time.Clock()

# === Helper voor tekst ===
def draw_text(text, font, color, x, y):
    img = font.render(text, True, color)
    rect = img.get_rect(center=(x, y))
    screen.blit(img, rect)

# === Naam invoeren ===
def enter_name():
    name = ""
    entering = True

    while entering:
        screen.fill((0, 0, 0))
        draw_text("Voer je naam in:", font_small, (255, 255, 255), WIDTH//2, HEIGHT//3)
        draw_text(name, font_med, (0, 200, 255), WIDTH//2, HEIGHT//2)
        draw_text("ENTER = ok | BACKSPACE = wis", font_small, (200, 200, 200), WIDTH//2, HEIGHT - 40)

        pygame.display.flip()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                GPIO.cleanup()
                pygame.quit()
                sys.exit()

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RETURN and name != "":
                    return name
                elif event.key == pygame.K_BACKSPACE:
                    name = name[:-1]
                else:
                    if len(name) < 12:
                        name += event.unicode

# === Timer spel ===
def run_timer():
    timer_running = False
    start_time = 0
    elapsed = 0

    prev_state = GPIO.input(BUTTON_PIN)

    while True:
        screen.fill((0, 0, 0))

        if timer_running:
            elapsed = time.time() - start_time

        draw_text(f"{elapsed:0.2f}", font_big, (255, 255, 0), WIDTH//2, HEIGHT//2)
        draw_text("Druk op de knop om te starten/stoppen", font_small, (200, 200, 200), WIDTH//2, HEIGHT - 40)

        pygame.display.flip()
        clock.tick(60)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                GPIO.cleanup()
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                GPIO.cleanup()
                pygame.quit()
                sys.exit()

        curr_state = GPIO.input(BUTTON_PIN)

        if prev_state == 1 and curr_state == 0:
            if not timer_running:
                timer_running = True
                start_time = time.time()
            else:
                return elapsed
            time.sleep(0.2)

        prev_state = curr_state

# === Result scherm ===
def show_result(name, time_val):
    deviation = round(time_val - 10, 2)
    scoreboard[name] = float(deviation)
    save_scores(scoreboard)

    while True:
        screen.fill((0, 0, 0))
        draw_text(f"{name}", font_med, (0, 200, 255), WIDTH//2, 80)
        draw_text(f"Tijd: {time_val:0.2f} s", font_small, (255, 255, 255), WIDTH//2, 180)
        draw_text(f"Fout: {deviation:+.3f}", font_small, (255, 150, 150), WIDTH//2, 260)
        draw_text("Druk ENTER voor nieuw spel", font_small, (200, 200, 200), WIDTH//2, HEIGHT - 80)
        draw_text("Druk S om scorebord te zien", font_small, (200, 200, 200), WIDTH//2, HEIGHT - 40)

        pygame.display.flip()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                GPIO.cleanup()
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RETURN:
                    return
                if event.key == pygame.K_s:
                    show_scoreboard()

# === Scorebord ===
def show_scoreboard():
    while True:
        screen.fill((0, 0, 0))
        draw_text("SCOREBORD", font_med, (255, 255, 0), WIDTH//2, 50)

        sorted_scores = sorted(scoreboard.items(), key=lambda x: abs(x[1]))
        top_five = sorted_scores[:5]

        y = 150
        for name, score in top_five:
            draw_text(f"{name}: {score:+.2f}", font_small, (255, 255, 255), WIDTH//2, y)
            y += 40

        draw_text("ENTER = terug", font_small, (200, 200, 200), WIDTH//2, HEIGHT - 40)
        pygame.display.flip()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                GPIO.cleanup()
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
                return

# === MAIN LOOP ===
try:
    while True:
        player = enter_name()
        result = run_timer()
        show_result(player, result)

except KeyboardInterrupt:
    GPIO.cleanup()
    pygame.quit()

// ╔══════════════════════════════════════════════════════════╗
// ║  LED TURRET — Kleur-editie  (Grove Shield versie)       ║
// ║  Knoppen: GEEL=D2  BLAUW=D4  ROOD=A0                   ║
// ║  LEDs:    GEEL=D3  BLAUW=D5  ROOD=D7                   ║
// ║  Ledstrip (WS2812B): D6  → externe 5V voeding!         ║
// ╠══════════════════════════════════════════════════════════╣
// ║  GROVE SHIELD AANPASSINGEN:                             ║
// ║  • Knoppen: INPUT_PULLUP  → ingedrukt = LOW            ║
// ║  • Arcade LEDs: active-low → LOW = aan, HIGH = uit     ║
// ║  • Ledstrip: sluit aan op externe 5V, GND gemeenschappelijk ║
// ╚══════════════════════════════════════════════════════════╝

#include <FastLED.h>

// ── Configuratie ────────────────────────────────────────────
#define NUM_LEDS        300
#define DATA_PIN          8   // WS2812B datakabel op D6

#define BTN_YELLOW        2
#define LED_YELLOW        3

#define BTN_BLUE          4
#define LED_BLUE          5

#define BTN_RED           6 
#define LED_RED           7

// ── Grove Shield / Arcade LED logica ───────────────────────
// Knoppen gebruiken INPUT_PULLUP: in rust = HIGH, ingedrukt = LOW
// Arcade LED is active-low: digitalWrite LOW = LED aan, HIGH = uit
#define LED_ON   LOW
#define LED_OFF  HIGH
#define BTN_PRESSED LOW    // met INPUT_PULLUP

#define MAX_ENEMIES      15
#define MAX_BULLETS      10
#define PLAYER_POS       10

#define COL_YELLOW  0
#define COL_BLUE    1
#define COL_RED     2
#define COL_NONE   -1

CRGB enemyColor(int c) {
  switch (c) {
    case COL_YELLOW: return CRGB(255, 255,   0);
    case COL_BLUE:   return CRGB(  0, 120, 255);
    case COL_RED:    return CRGB(255,  20,  20);
    default:         return CRGB(255, 255, 255);
  }
}

CRGB bulletColor(int c) {
  switch (c) {
    case COL_YELLOW: return CRGB(255, 255,   0);
    case COL_BLUE:   return CRGB(  0, 120, 255);
    case COL_RED:    return CRGB(255,  20,  20);
    default:         return CRGB(255, 255, 255);
  }
}

#define C_HIT      CRGB(255, 255, 255)
#define C_TURRET   CRGB(  0, 255, 160)
#define C_OFF      CRGB(  0,   0,   0)

struct Enemy {
  int           pos;
  bool          alive;
  bool          hit_flash;
  int           color_type;
  unsigned long last_move;
  unsigned long move_interval;
};

struct Bullet {
  int  pos;
  bool active;
  int  color_type;
};

struct Explosion {
  int           center;
  int           radius;
  bool          active;
  unsigned long last_update;
  CRGB          color;
};

CRGB      leds[NUM_LEDS];
Enemy     enemies[MAX_ENEMIES];
Bullet    bullets[MAX_BULLETS];
Explosion explosion;

int           wave              = 5;
int           score             = 0;
int           lives             = 3;
unsigned long last_spawn        = 0;
unsigned long spawn_interval    = 1200;
unsigned long last_bullet_move  = 0;
int           enemies_this_wave = 3;
int           spawned_count     = 0;

#define BASE_SPEED      80
#define SPEED_PER_WAVE   8
#define MIN_SPEED       25
#define BULLET_SPEED      6
#define EXPLOSION_SPEED  90
#define ACCEL_ZONE       40

// Met INPUT_PULLUP is de beginstand HIGH (niet ingedrukt)
bool          btn_prev[3]      = {HIGH, HIGH, HIGH};
bool          shooting         = false;
unsigned long shoot_flash_end  = 0;
int           shoot_color      = COL_NONE;

// LED flitst 80ms bij klik
unsigned long led_flash_end[3] = {0, 0, 0};
#define LED_FLASH_MS  80

unsigned long last_shot[3]     = {0, 0, 0};

// ── Prototypes ───────────────────────────────────────────────
void startWave(int w);
void checkWaveComplete();
void spawnEnemy(unsigned long now);
void moveEnemies(unsigned long now);
void moveBullets(unsigned long now);
void updateExplosion(unsigned long now);
void handleButtons(unsigned long now);
void fireBullet(int color_type, unsigned long now);
void render(unsigned long now);
void triggerExplosion(int pos, CRGB col);
void waveStartAnimation();
void loseLifeAnimation();
void gameOver();
void resetGame();
void resetEnemies();
void resetBullets();
void sendSerial();
int  freeEnemySlot();
int  freeBulletSlot();
unsigned long waveSpeed(int w);

// ── Setup ────────────────────────────────────────────────────
void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(60);
  // Geen setMaxPower via Arduino 5V pin — ledstrip heeft externe voeding
  // FastLED.setMaxPowerInVoltsAndMilliamps(5, 500); // alleen als je via Arduino voedt (NIET aanbevolen bij 300 leds)

  // INPUT_PULLUP: interne pull-up weerstand actief
  // In rust leest de pin HIGH, ingedrukt trekt de knop naar GND → LOW
  pinMode(BTN_YELLOW, INPUT_PULLUP);
  pinMode(BTN_BLUE,   INPUT_PULLUP);
  pinMode(BTN_RED,    INPUT_PULLUP);

  // Arcade LED outputs — active-low: HIGH = uit (initieel)
  pinMode(LED_YELLOW, OUTPUT);
  pinMode(LED_BLUE,   OUTPUT);
  pinMode(LED_RED,    OUTPUT);

  digitalWrite(LED_YELLOW, LED_OFF);
  digitalWrite(LED_BLUE,   LED_OFF);
  digitalWrite(LED_RED,    LED_OFF);

  Serial.begin(9600);
  explosion.active = false;
  resetEnemies();
  resetBullets();
  startWave(wave);
}

// ── Loop ─────────────────────────────────────────────────────
void loop() {
  unsigned long now = millis();
  handleButtons(now);
  spawnEnemy(now);
  moveEnemies(now);
  moveBullets(now);
  updateExplosion(now);
  checkWaveComplete();
  render(now);
  FastLED.show();
}

unsigned long waveSpeed(int w) {
  int speed = BASE_SPEED - (w - 1) * SPEED_PER_WAVE;
  return (unsigned long) max(speed, MIN_SPEED);
}

void startWave(int w) {
  wave              = w;
  spawned_count     = 0;
  enemies_this_wave = 5 + (w - 1) * 3;
  spawn_interval    = max(300UL, 1200UL - (unsigned long)(w - 1) * 100UL);
  last_spawn        = millis() - spawn_interval;
  Serial.print("WAVE:"); Serial.println(wave);
  sendSerial();
  waveStartAnimation();
}

void checkWaveComplete() {
  if (spawned_count < enemies_this_wave) return;
  for (int i = 0; i < MAX_ENEMIES; i++)
    if (enemies[i].alive) return;
  delay(800);
  startWave(wave + 1);
}

int freeEnemySlot() {
  for (int i = 0; i < MAX_ENEMIES; i++)
    if (!enemies[i].alive) return i;
  return -1;
}

int freeBulletSlot() {
  for (int i = 0; i < MAX_BULLETS; i++)
    if (!bullets[i].active) return i;
  return -1;
}

void spawnEnemy(unsigned long now) {
  if (spawned_count >= enemies_this_wave) return;
  if (now - last_spawn < spawn_interval)  return;
  last_spawn = now;
  int slot = freeEnemySlot();
  if (slot < 0) return;
  int col = random(3);
  enemies[slot].pos           = NUM_LEDS - 1;
  enemies[slot].alive         = true;
  enemies[slot].hit_flash     = false;
  enemies[slot].color_type    = col;
  enemies[slot].last_move     = now;
  enemies[slot].move_interval = waveSpeed(wave);
  spawned_count++;
}

void moveEnemies(unsigned long now) {
  for (int i = 0; i < MAX_ENEMIES; i++) {
    if (!enemies[i].alive) continue;
    unsigned long interval = enemies[i].move_interval;
    int dist = enemies[i].pos - PLAYER_POS;
    if (dist < ACCEL_ZONE && dist > 0) {
      interval = interval * dist / ACCEL_ZONE;
      interval = max(interval, 15UL);
    }
    if (now - enemies[i].last_move < interval) continue;
    enemies[i].last_move  = now;
    enemies[i].hit_flash  = false;
    enemies[i].pos--;
    if (enemies[i].pos <= PLAYER_POS) {
      enemies[i].alive = false;
      lives--;
      Serial.print("LIVES:"); Serial.println(lives);
      loseLifeAnimation();
      if (lives <= 0) gameOver();
    }
  }
}

void handleButtons(unsigned long now) {
  int btnPins[3] = { BTN_YELLOW, BTN_BLUE, BTN_RED };
  int ledPins[3] = { LED_YELLOW, LED_BLUE, LED_RED };
  int colors[3]  = { COL_YELLOW, COL_BLUE, COL_RED };

  for (int k = 0; k < 3; k++) {
    bool btn = digitalRead(btnPins[k]);

    // INPUT_PULLUP: ingedrukt = LOW, leading edge = van HIGH naar LOW
    bool pressed = (btn == BTN_PRESSED && btn_prev[k] == HIGH);

    if (pressed) {
      fireBullet(colors[k], now);
      last_shot[k]     = now;
      shooting         = true;
      shoot_color      = colors[k];
      shoot_flash_end  = now + 60;
      led_flash_end[k] = now + LED_FLASH_MS;
      digitalWrite(ledPins[k], LED_ON);   // active-low: LOW = aan
    }

    // LED uit na flash-periode
    if (now >= led_flash_end[k]) {
      digitalWrite(ledPins[k], LED_OFF);  // active-low: HIGH = uit
    }

    btn_prev[k] = btn;
  }

  if (now > shoot_flash_end) {
    shooting    = false;
    shoot_color = COL_NONE;
  }
}

void fireBullet(int color_type, unsigned long now) {
  int count = 0;
  for (int i = 0; i < MAX_BULLETS; i++)
    if (bullets[i].active && bullets[i].color_type == color_type) count++;
  if (count >= 3) return;
  int slot = freeBulletSlot();
  if (slot < 0) return;
  bullets[slot].pos        = PLAYER_POS + 1;
  bullets[slot].active     = true;
  bullets[slot].color_type = color_type;
}

bool checkBulletCollision(int b) {
  for (int i = 0; i < MAX_ENEMIES; i++) {
    if (!enemies[i].alive) continue;
    bool hit = (bullets[b].pos == enemies[i].pos ||
                bullets[b].pos - 1 == enemies[i].pos);
    if (!hit) continue;
    if (bullets[b].color_type == enemies[i].color_type) {
      triggerExplosion(enemies[i].pos, enemyColor(enemies[i].color_type));
      enemies[i].alive = false;
      score += 10;
      Serial.print("SCORE:"); Serial.println(score);
    } else {
      // Foute kleur: -5 punten, nooit onder 0
      score = max(0, score - 5);
      Serial.print("SCORE:"); Serial.println(score);
      enemies[i].hit_flash = true;
    }
    return true;
  }
  return false;
}

void moveBullets(unsigned long now) {
  if (now - last_bullet_move < BULLET_SPEED) return;
  last_bullet_move = now;
  for (int b = 0; b < MAX_BULLETS; b++) {
    if (!bullets[b].active) continue;
    bullets[b].pos++;
    if (bullets[b].pos >= NUM_LEDS) {
      bullets[b].active = false;
      continue;
    }
    if (checkBulletCollision(b)) bullets[b].active = false;
  }
}

void triggerExplosion(int pos, CRGB col) {
  explosion.center      = pos;
  explosion.radius      = 0;
  explosion.active      = true;
  explosion.last_update = millis();
  explosion.color       = col;
}

void updateExplosion(unsigned long now) {
  if (!explosion.active) return;
  if (now - explosion.last_update < EXPLOSION_SPEED) return;
  explosion.last_update = now;
  explosion.radius++;
  if (explosion.radius > 6) explosion.active = false;
}

void render(unsigned long now) {
  fill_solid(leds, NUM_LEDS, C_OFF);
  if (explosion.active) {
    int r = explosion.radius;
    uint8_t br = map(r, 0, 6, 255, 0);
    CRGB col = explosion.color;
    col.nscale8(br);
    for (int i = explosion.center - r; i <= explosion.center + r; i++)
      if (i >= 0 && i < NUM_LEDS) leds[i] = col;
  }
  for (int i = 0; i < lives && i < 5; i++)
    leds[PLAYER_POS - 1 - i] = CRGB(180, 0, 0);
  if (shooting && shoot_color != COL_NONE)
    leds[PLAYER_POS] = bulletColor(shoot_color);
  else
    leds[PLAYER_POS] = C_TURRET;
  for (int i = 0; i < MAX_ENEMIES; i++) {
    if (!enemies[i].alive) continue;
    int p = enemies[i].pos;
    if (p < 0 || p >= NUM_LEDS) continue;
    leds[p] = enemies[i].hit_flash ? C_HIT : enemyColor(enemies[i].color_type);
  }
  for (int b = 0; b < MAX_BULLETS; b++) {
    if (!bullets[b].active) continue;
    int p = bullets[b].pos;
    if (p >= 0 && p < NUM_LEDS) leds[p] = bulletColor(bullets[b].color_type);
    int p2 = bullets[b].pos - 1;
    if (p2 >= 0 && p2 < NUM_LEDS) leds[p2] = bulletColor(bullets[b].color_type);
  }
}

void sendSerial() {
  Serial.print("STATUS:{\"score\":");
  Serial.print(score);
  Serial.print(",\"lives\":");
  Serial.print(lives);
  Serial.print(",\"wave\":");
  Serial.print(wave);
  Serial.print(",\"bullets\":3}");
  Serial.println();
}

void waveStartAnimation() {
  CRGB cols[3] = { CRGB(255,200,0), CRGB(0,120,255), CRGB(255,20,20) };
  // Alle arcade LEDs even aan tijdens animatie (active-low)
  digitalWrite(LED_YELLOW, LED_ON);
  digitalWrite(LED_BLUE,   LED_ON);
  digitalWrite(LED_RED,    LED_ON);
  for (int c = 0; c < 3; c++) {
    fill_solid(leds, NUM_LEDS, cols[c]);
    FastLED.show(); delay(80);
    fill_solid(leds, NUM_LEDS, C_OFF);
    FastLED.show(); delay(50);
  }
  digitalWrite(LED_YELLOW, LED_OFF);
  digitalWrite(LED_BLUE,   LED_OFF);
  digitalWrite(LED_RED,    LED_OFF);
}

void loseLifeAnimation() {
  fill_solid(leds, NUM_LEDS, CRGB(180, 0, 0));
  FastLED.show(); delay(300);
  fill_solid(leds, NUM_LEDS, C_OFF);
  FastLED.show(); delay(100);
  sendSerial();
}

void gameOver() {
  Serial.print("GAMEOVER:"); Serial.println(score);
  // Alle arcade LEDs knipperen mee bij game over
  for (int j = 0; j < 6; j++) {
    fill_solid(leds, NUM_LEDS, CRGB(200, 0, 0));
    FastLED.show();
    digitalWrite(LED_YELLOW, LED_ON);
    digitalWrite(LED_BLUE,   LED_ON);
    digitalWrite(LED_RED,    LED_ON);
    delay(180);
    fill_solid(leds, NUM_LEDS, C_OFF);
    FastLED.show();
    digitalWrite(LED_YELLOW, LED_OFF);
    digitalWrite(LED_BLUE,   LED_OFF);
    digitalWrite(LED_RED,    LED_OFF);
    delay(180);
  }
  resetGame();
}

void resetGame() {
  lives            = 3;
  score            = 0;
  explosion.active = false;
  resetEnemies();
  resetBullets();
  sendSerial();
  startWave(5);
}

void resetEnemies() {
  for (int i = 0; i < MAX_ENEMIES; i++) enemies[i].alive = false;
  spawned_count = 0;
}

void resetBullets() {
  for (int i = 0; i < MAX_BULLETS; i++) bullets[i].active = false;
}

import serial
import json
import tkinter as tk
from tkinter import font as tkfont
import threading
import time
import os
import sys

# ── Configuratie ────────────────────────────────────────────
SERIAL_PORT = "COM8"       # Windows: COM3, COM4, ...  |  Mac/Linux: /dev/ttyUSB0 of /dev/ttyACM0
BAUD_RATE   = 9600
SCORES_FILE = "highscores.json"

# ── Highscore opslaan/laden ──────────────────────────────────
def load_scores():
    if os.path.exists(SCORES_FILE):
        with open(SCORES_FILE, "r") as f:
            return json.load(f)
    return {"highscore": 0, "history": []}

def save_score(score):
    data = load_scores()
    if score > data["highscore"]:
        data["highscore"] = score
    data["history"].append({"score": score, "time": time.strftime("%Y-%m-%d %H:%M")})
    data["history"] = data["history"][-10:]  # bewaar laatste 10
    with open(SCORES_FILE, "w") as f:
        json.dump(data, f, indent=2)
    return data["highscore"]

# ── GUI ──────────────────────────────────────────────────────
class ScoreDisplay:
    def __init__(self, root):
        self.root = root
        self.root.title("LED TURRET — Score")
        self.root.configure(bg="#0a0a0f")
        self.root.geometry("480x520")
        self.root.resizable(False, False)

        self.score     = 0
        self.lives     = 3
        self.wave      = 1
        self.bullets   = 1
        self.highscore = load_scores()["highscore"]
        self.game_over = False

        self._build_ui()
        self._start_serial()

    def _build_ui(self):
        # Fonts
        big   = tkfont.Font(family="Courier New", size=52, weight="bold")
        med   = tkfont.Font(family="Courier New", size=18, weight="bold")
        small = tkfont.Font(family="Courier New", size=13)
        tiny  = tkfont.Font(family="Courier New", size=10)

        pad = dict(bg="#0a0a0f")

        # Titel
        tk.Label(self.root, text="◈ LED TURRET ◈", font=med,
                 fg="#00b4ff", **pad).pack(pady=(18, 0))

        # Score groot
        self.lbl_score = tk.Label(self.root, text="0", font=big,
                                  fg="#ffffff", **pad)
        self.lbl_score.pack(pady=(4, 0))

        tk.Label(self.root, text="SCORE", font=small,
                 fg="#444466", **pad).pack()

        # Highscore
        self.lbl_hs = tk.Label(self.root,
                               text=f"BEST  {self.highscore}",
                               font=small, fg="#ffcc00", **pad)
        self.lbl_hs.pack(pady=(2, 10))

        # Scheidingslijn
        tk.Frame(self.root, height=1, bg="#222244").pack(fill="x", padx=30)

        # Stats rij
        stats = tk.Frame(self.root, **pad)
        stats.pack(pady=14)

        # Wave
        wf = tk.Frame(stats, **pad)
        wf.grid(row=0, column=0, padx=24)
        tk.Label(wf, text="WAVE", font=tiny, fg="#444466", **pad).pack()
        self.lbl_wave = tk.Label(wf, text="1", font=med, fg="#00ff99", **pad)
        self.lbl_wave.pack()

        # Levens
        lf = tk.Frame(stats, **pad)
        lf.grid(row=0, column=1, padx=24)
        tk.Label(lf, text="LIVES", font=tiny, fg="#444466", **pad).pack()
        self.lbl_lives = tk.Label(lf, text="♥ ♥ ♥", font=med, fg="#ff3355", **pad)
        self.lbl_lives.pack()

        # Kogels
        bf = tk.Frame(stats, **pad)
        bf.grid(row=0, column=2, padx=24)
        tk.Label(bf, text="BULLETS", font=tiny, fg="#444466", **pad).pack()
        self.lbl_bullets = tk.Label(bf, text="●", font=med, fg="#ffcc00", **pad)
        self.lbl_bullets.pack()

        tk.Frame(self.root, height=1, bg="#222244").pack(fill="x", padx=30)

        # Status bericht
        self.lbl_status = tk.Label(self.root, text="",
                                   font=med, fg="#ff3355", **pad)
        self.lbl_status.pack(pady=14)

        # Recente scores
        tk.Label(self.root, text="LAATSTE SCORES", font=tiny,
                 fg="#333355", **pad).pack()
        self.lbl_history = tk.Label(self.root, text="",
                                    font=tiny, fg="#555577", **pad)
        self.lbl_history.pack(pady=4)

        self._refresh_history()

    def _refresh_history(self):
        data = load_scores()
        lines = [f"{e['time']}   {e['score']:>6}" for e in reversed(data["history"][-5:])]
        self.lbl_history.config(text="\n".join(lines) if lines else "—")

    def update(self, score=None, lives=None, wave=None, bullets=None):
        if score   is not None: self.score   = score
        if lives   is not None: self.lives   = lives
        if wave    is not None: self.wave    = wave
        if bullets is not None: self.bullets = bullets

        self.lbl_score.config(text=str(self.score))
        self.lbl_wave.config(text=str(self.wave))
        self.lbl_lives.config(text=" ".join(["♥"] * max(0, self.lives)))
        self.lbl_bullets.config(text=" ".join(["●"] * self.bullets))

        if self.score > self.highscore:
            self.highscore = self.score
            self.lbl_hs.config(text=f"BEST  {self.highscore}")

    def handle_gameover(self, final_score):
        new_hs = save_score(final_score)
        self.highscore = new_hs
        self.lbl_hs.config(text=f"BEST  {self.highscore}")
        self.lbl_status.config(text="★ GAME OVER ★")
        self._refresh_history()
        # status na 3s weer leeg
        self.root.after(3000, lambda: self.lbl_status.config(text=""))

    # ── Serial lezen in aparte thread ───────────────────────
    def _start_serial(self):
        t = threading.Thread(target=self._serial_loop, daemon=True)
        t.start()

    def _serial_loop(self):
        ser = None
        while ser is None:
            try:
                ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)
                print(f"Verbonden op {SERIAL_PORT}")
            except Exception:
                print(f"Wacht op {SERIAL_PORT}...")
                time.sleep(2)

        while True:
            try:
                raw = ser.readline().decode("utf-8", errors="ignore").strip()
                if not raw:
                    continue
                print(raw)  # debug

                if raw.startswith("STATUS:"):
                    # STATUS:{"score":10,"lives":3,"wave":1,"bullets":2}
                    payload = raw[7:]
                    d = json.loads(payload)
                    self.root.after(0, lambda d=d: self.update(
                        score=d.get("score"),
                        lives=d.get("lives"),
                        wave=d.get("wave"),
                        bullets=d.get("bullets"),
                    ))

                elif raw.startswith("SCORE:"):
                    s = int(raw.split(":")[1])
                    self.root.after(0, lambda s=s: self.update(score=s))

                elif raw.startswith("LIVES:"):
                    l = int(raw.split(":")[1])
                    self.root.after(0, lambda l=l: self.update(lives=l))

                elif raw.startswith("WAVE:"):
                    w = int(raw.split(":")[1])
                    self.root.after(0, lambda w=w: self.update(wave=w))

                elif raw.startswith("BULLETS:"):
                    b = int(raw.split(":")[1])
                    self.root.after(0, lambda b=b: self.update(bullets=b))

                elif raw.startswith("GAMEOVER:"):
                    s = int(raw.split(":")[1])
                    self.root.after(0, lambda s=s: self.handle_gameover(s))

            except Exception as e:
                print(f"Serial fout: {e}")
                time.sleep(0.5)

# ── Main ─────────────────────────────────────────────────────
if __name__ == "__main__":
    if len(sys.argv) > 1:
        SERIAL_PORT = sys.argv[1]   # python score.py COM5

    root = tk.Tk()
    app  = ScoreDisplay(root)
    root.mainloop()