Schne­cken­ren­nen

Zwei Schne­cken lie­fern sich ein Ren­nen. Sie lau­fen eine zufäl­lig ermit­tel­te Anzahl von Schrit­ten. Wer als Ers­tes mit dem letz­ten Zug das Ziel über­schrei­tet, hat gewonnen. 

So sieht es aus:

Auf einem LCD:

Schne­cken­ren­nen LCD

Im Seri­el­len Monitor:

Schne­cken­ren­nen mit einer Schnecke

Im Kopf des Pro­gramms wer­den ver­schie­de­ne ➨Arrays ver­wen­det, damit die Aus­ga­be mög­lichst fle­xi­bel gestal­tet wer­den kann. Beach­te die Kommentare.

// Anzahl der Schritte Minimum/Maximum
int Minimum = 1;
int Maximum = 4;

// Schritte bis zum Ziel
int Ziel = 10;

int Schritte = 0;
int Runde = 1;

// wenn Neustart = true -> Variable zurücksetzen
bool Neustart = false;

/*
  Arrays für die Schnecken
  BisherigeSchritte[] -> Anzahl zurückgelegter Schritte
  Schnecke[] -> Namen der Schnecken
  SchrittZeichen[] -> Zeichen für die zurückgelegten Schritte
  es können (fast) beliebige Zeichen verwendet werden
*/
int BisherigeSchritte[2];
String Schnecke[2] = {"Lisa", "Karl"};
String SchrittZeichen[2] = {"> ", "+ "};

Im setup-Teil wird über die Ent­fer­nung zum Ziel, die betei­lig­ten Schne­cken und über die Tas­ten­be­le­gung informiert.

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // Info über das Spiel
  Serial.println("Schneckenrennen");
  Serial.println("Schnecken: " + Schnecke[0] + " und " + Schnecke[1]);

  // \n = neue Zeile
  Serial.println("Ziel: " + String(Ziel));
  Serial.println("Tasten:\nw -> weiter\nn -> Neustart");
  Serial.println("-------------------------------------------");

  // Zufallsgenerator starten
  randomSeed(analogRead(0));
}

Der loop-Teil. Beach­te die Kommentare.

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    char Zeichen = Serial.read();

    // Enter/Senden gedrückt
    if (Zeichen == 'n')
    {
      Neustart = true;
    }

    if (Zeichen == 'w')
    {
      // beim Neustart -> alle Variablen zurücksetzen
      if (Neustart)
      {
        BisherigeSchritte[0] = 0;
        BisherigeSchritte[1] = 0;
        Runde = 1;
        Neustart = false;
      }

      Serial.println("Runde " + String(Runde));

      // Schnecke 1
      // Anzahl der Schritte zufällig ermitteln
      Schritte = ZufallsZahl(Minimum, Maximum);

      // Summe der Schritte berechnen
      BisherigeSchritte[0] = BisherigeSchritte[0] + Schritte;

      /*
        Variablen an die Methode Bildschirmausgabe übergeben
        Name der Schnecke, Summe der Schritte, 
        Zeichen für die zurückgelegten Schritte
        für das erste Element [0] -> die erste Schnecke
      */
      Bildschirmausgabe(Schnecke[0], BisherigeSchritte[0], SchrittZeichen[0]);

      /*
        Variablen an die Methode Bildschirmausgabe übergeben
        Name der Schnecke, Summe der Schritte, 
        Zeichen für die zurückgelegten Schritte
        für das zweite Element [1] -> die zweite Schnecke
      */
      Schritte = ZufallsZahl(Minimum, Maximum);
      BisherigeSchritte[1] = BisherigeSchritte[1] + Schritte;
      Bildschirmausgabe(Schnecke[1], BisherigeSchritte[1], SchrittZeichen[1]);

      Serial.println("-------------------------------------------");

      // Runde hochzählen
      Runde ++;

      // Sieger Schnecke 1
      if (BisherigeSchritte[0] > Ziel)
      {
        if (BisherigeSchritte[0] > BisherigeSchritte[1])
        {
          Serial.println(Schnecke[0] + " hat gewonnen!");
          Neustart = true;
        }
      }

      // Sieger Schnecke 2
      if (BisherigeSchritte[1] > Ziel)
      {
        if (BisherigeSchritte[0] < BisherigeSchritte[1])
        {
          Serial.println(Schnecke[1] + " hat gewonnen!");
          Neustart = true;
        }
      }

      // unentschieden
      if (BisherigeSchritte[0] > Ziel && BisherigeSchritte[1] > Ziel)
      {
        if (BisherigeSchritte[0] == BisherigeSchritte[1])
        {
          Serial.println("Unentschieden!");
          Neustart = true;
        }
      }
    }
  }
}

Jetzt feh­len noch die Funk­ti­on Zufalls­Zahl() und die Metho­de Bildschirmausgabe().

int ZufallsZahl(int Minimum, int Maximum)
{
  int Zahl =  random(Minimum, Maximum);
  return Zahl;
}

void Bildschirmausgabe(String Name, int Schritte, String SchrittZeichen)
{
  // Name der Schnecke und Anzahl der Schritte anzeigen
  Serial.println(Name + " " + String(Schritte));

  // entsprechend der Anzahl der Schritte Zeichen anzeigen
  for (int i = 0; i < Schritte; i ++)
  {
    Serial.print(SchrittZeichen);
  }

  // mit Leerzeichen auffüllen und Ziel anzeigen
  if (Schritte <= Ziel)
  {
    for (int i = Schritte; i < Ziel; i ++)
    {
      Serial.print("  ");
    }
    Serial.print("| Ziel");
  }
  Serial.println();
}

Erwei­te­re das Pro­gramm auf drei Schnecken.

So sieht es aus:

Ver­wand­te Aufgaben:

• Ein­mal­eins­rei­hen anzeigen
• Fuß­ball­tipp
• Geld­au­to­mat
• Lot­to­zah­len - Anzei­ge im Seri­el­len Monitor
• Prim­zah­len ermitteln
• Satz­ma­schi­ne
• Städte-Info
• Taschen­rech­ner Grundrechenarten
• Tei­ler bestimmen
• Voka­le zählen
• Voll­kom­me­ne Zahlen
• Wür­feln Seri­el­ler Monitor

Letzte Aktualisierung: 11. Aug 2022 @ 10:00