Fähnchen, Sieg und Niederlage

Cargo.toml

[package]
name = "wattlaeufer"
version = "0.1.0"
edition = "2024"

[dependencies]
iced = { version = "0.14", features = ["svg"] }
rand = "0.10"

src/main.rs

use iced::widget::{column, container, mouse_area, row, svg, text};
use iced::{mouse, Background, Border, Color, Element, Fill, Font, Theme};

// Die Farben des Watts
const MEER: Color = Color::from_rgb8(0x1f, 0x4e, 0x6b);
const SCHAUM: Color = Color::from_rgb8(0xf4, 0xf1, 0xe8);
const SAND: Color = Color::from_rgb8(0xe8, 0xc9, 0x8f);
const SAND_KANTE: Color = Color::from_rgb8(0xc9, 0xa4, 0x62);
const NASS: Color = Color::from_rgb8(0xb9, 0xa8, 0x86);
const ROT: Color = Color::from_rgb8(0xd9, 0x4a, 0x2b);

// So groß ist ein Feld, in Pixeln
const FELD: f32 = 44.0;

// So groß ist das Watt
const BREITE: usize = 9;
const HOEHE: usize = 9;

// So viele Krebse verstecken sich im Watt
const KREBSE: usize = 10;

// Ein kleines Warnfähnchen als SVG-Grafik
const FAHNE: &[u8] = br##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
  <rect x="6" y="3" width="2" height="18" fill="#3b2a1a"/>
  <path d="M8 4 L19 8 L8 12 Z" fill="#d94a2b"/>
  <ellipse cx="7" cy="21" rx="5" ry="1.5" fill="#8a6a3a"/>
</svg>"##;

fn main() -> iced::Result {
    iced::application(Watt::neu, Watt::update, Watt::view)
        .title("Wattläufer")
        .default_font(Font::MONOSPACE)
        .window_size((460.0, 560.0))
        .run()
}

// Ein Feld ist entweder noch verdeckt oder schon aufgedeckt.
#[derive(Clone, Copy, PartialEq)]
enum Zustand {
    Verdeckt,
    Markiert,
    Aufgedeckt,
}

// Alles, was wir über ein einzelnes Feld wissen.
#[derive(Clone, Copy)]
struct Feld {
    krebs: bool,
    nachbarn: u8,
    zustand: Zustand,
}

// Läuft das Spiel noch, oder ist es vorbei?
#[derive(PartialEq)]
enum Spiel {
    Laeuft,
    Gewonnen,
    Verloren,
}

// Das ganze Watt: eine Liste aller Felder.
struct Watt {
    felder: Vec<Feld>,
    spiel: Spiel,
}

#[derive(Debug, Clone)]
enum Message {
    Aufdecken(usize),
    Markieren(usize),
}

impl Watt {
    // Legt ein neues Watt an, in dem alle Felder verdeckt sind.
    fn neu() -> Self {
        let leer = Feld {
            krebs: false,
            nachbarn: 0,
            zustand: Zustand::Verdeckt,
        };
        let mut felder = vec![leer; BREITE * HOEHE];

        // Zehn verschiedene Feldnummern auslosen und dort Krebse verstecken
        let mut rng = rand::rng();
        for i in rand::seq::index::sample(&mut rng, BREITE * HOEHE, KREBSE) {
            felder[i].krebs = true;
        }

        // Für jedes Feld zählen, wie viele Krebse in den Nachbarfeldern stecken
        for i in 0..felder.len() {
            let mut anzahl = 0;
            for n in nachbarn(i) {
                if felder[n].krebs {
                    anzahl += 1;
                }
            }
            felder[i].nachbarn = anzahl;
        }

        Watt { felder, spiel: Spiel::Laeuft }
    }

    fn update(&mut self, message: Message) {
        match message {
            Message::Aufdecken(i) => {
                if self.spiel != Spiel::Laeuft {
                    return; // Spiel vorbei: Klicks werden ignoriert
                }
                if self.felder[i].zustand != Zustand::Verdeckt {
                    return; // Fähnchen oder schon offen: nicht aufdecken
                }
                if self.felder[i].krebs {
                    self.spiel = Spiel::Verloren;
                    self.alle_krebse_zeigen();
                } else {
                    self.aufdecken(i);
                    if self.alles_sicher_aufgedeckt() {
                        self.spiel = Spiel::Gewonnen;
                    }
                }
            }
            Message::Markieren(i) => {
                if self.spiel != Spiel::Laeuft {
                    return;
                }
                let feld = &mut self.felder[i];
                feld.zustand = match feld.zustand {
                    Zustand::Verdeckt => Zustand::Markiert,
                    Zustand::Markiert => Zustand::Verdeckt,
                    Zustand::Aufgedeckt => Zustand::Aufgedeckt,
                };
            }
        }
    }

    // Deckt Feld i auf. Hat es keine Krebs-Nachbarn, deckt es auch alle Nachbarn auf.
    fn aufdecken(&mut self, i: usize) {
        if self.felder[i].zustand != Zustand::Verdeckt {
            return; // schon aufgedeckt: nichts zu tun
        }
        self.felder[i].zustand = Zustand::Aufgedeckt;

        if self.felder[i].nachbarn == 0 && !self.felder[i].krebs {
            for n in nachbarn(i) {
                self.aufdecken(n);
            }
        }
    }

    // Deckt alle Krebse auf, damit man sieht, wo sie steckten.
    fn alle_krebse_zeigen(&mut self) {
        for feld in &mut self.felder {
            if feld.krebs {
                feld.zustand = Zustand::Aufgedeckt;
            }
        }
    }

    // Gewonnen hat, wer jedes Feld ohne Krebs aufgedeckt hat.
    fn alles_sicher_aufgedeckt(&self) -> bool {
        self.felder
            .iter()
            .all(|feld| feld.krebs || feld.zustand == Zustand::Aufgedeckt)
    }

    fn view(&self) -> Element<'_, Message> {
        let titel = text("WATTLÄUFER").size(22).color(SCHAUM);

        let fahnen = self
            .felder
            .iter()
            .filter(|feld| feld.zustand == Zustand::Markiert)
            .count();

        let status = match self.spiel {
            Spiel::Laeuft => format!("Krebse im Watt: {}", KREBSE as i32 - fahnen as i32),
            Spiel::Gewonnen => String::from("Geschafft! Trockene Füße."),
            Spiel::Verloren => String::from("Autsch! Gezwickt."),
        };

        let mut watt = column![].spacing(3);
        for y in 0..HOEHE {
            let mut reihe = row![].spacing(3);
            for x in 0..BREITE {
                let i = y * BREITE + x;
                reihe = reihe.push(self.feld_ansicht(i));
            }
            watt = watt.push(reihe);
        }

        let inhalt = column![titel, text(status).color(SCHAUM), watt].spacing(14);

        container(inhalt)
            .padding(20)
            .width(Fill)
            .height(Fill)
            .style(|_theme: &Theme| container::Style {
                background: Some(Background::Color(MEER)),
                ..container::Style::default()
            })
            .into()
    }

    // Zeichnet das Feld Nummer i, je nachdem, in welchem Zustand es ist.
    fn feld_ansicht(&self, i: usize) -> Element<'_, Message> {
        let feld = self.felder[i];
        let verdeckt = feld.zustand != Zustand::Aufgedeckt;
        let grund = if verdeckt {
            SAND
        } else if feld.krebs {
            ROT
        } else {
            NASS
        };

        let inhalt: Element<'_, Message> = if feld.zustand == Zustand::Markiert {
            svg(svg::Handle::from_memory(FAHNE)).width(26).height(26).into()
        } else if !verdeckt && !feld.krebs && feld.nachbarn > 0 {
            text(feld.nachbarn).size(20).color(zahlfarbe(feld.nachbarn)).into()
        } else {
            text("").into()
        };

        let kachel = container(inhalt)
            .center(FELD)
            .style(move |_theme: &Theme| container::Style {
                background: Some(Background::Color(grund)),
                border: Border {
                    color: SAND_KANTE,
                    width: if verdeckt { 2.0 } else { 0.0 },
                    radius: 6.0.into(),
                },
                ..container::Style::default()
            });

        mouse_area(kachel)
            .on_press(Message::Aufdecken(i))
            .on_right_press(Message::Markieren(i))
            .interaction(mouse::Interaction::Pointer)
            .into()
    }
}

// Liefert die Nummern aller Nachbarfelder von Feld i (höchstens acht).
fn nachbarn(i: usize) -> Vec<usize> {
    let x = (i % BREITE) as i32;
    let y = (i / BREITE) as i32;
    let mut liste = Vec::new();

    for dy in -1..=1 {
        for dx in -1..=1 {
            if dx == 0 && dy == 0 {
                continue; // das Feld selbst ist nicht sein eigener Nachbar
            }
            let nx = x + dx;
            let ny = y + dy;
            if nx >= 0 && nx < BREITE as i32 && ny >= 0 && ny < HOEHE as i32 {
                liste.push(ny as usize * BREITE + nx as usize);
            }
        }
    }
    liste
}

// Jede Zahl bekommt ihre eigene Farbe, damit man sie schneller erkennt.
fn zahlfarbe(anzahl: u8) -> Color {
    match anzahl {
        1 => MEER,
        2 => Color::from_rgb8(0x2e, 0x7d, 0x4f),
        3 => Color::from_rgb8(0xc2, 0x3b, 0x22),
        _ => Color::from_rgb8(0x5a, 0x2a, 0x6e),
    }
}