Projekt: Hangman [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Projekt: Hangman ======

**Slides:**

   * {{ :ef_informatik:efif_jahr_a_scope_wert_referenztypen.pdf | Slides: Scope, Wert- & Referenztypen}}
   * {{ :ef_informatik:efif_jahr_a_model_vs_view_hangman.pdf |Slides: Model vs. View & HangMan}}

**Ziele:**

   * Programmiere das bekannte Hangman-Game als **Konsolenapp**.
   * **Grösseres Programm** schreiben (ca. $300$ Zeilen Code)
   * Lerne, wie man anhand des Programmierparadigmas **Model vs. View** Code sinnvoll strukturiert.
   * **Scope** von Variablen verstehen.
   * Unterschied **Werttypen vs. Referenztypen** verstehen.
   * **Robusten Code** schreiben, der für alle Eventualitäten gewappnet ist.


**Auftrag:**

   1. Erstelle ein **neues GitHub-Repo "HangMan"** und teile es mit den Lehrpersonen. Wähle beim erstellen *private* und *Visual Studio* für das GitIgnore-File. Klone das Repo auf deinen Computer und ...
   1. ... erstelle darin ein neues C#-Konsolenprogramm mit Namen "HangMan". Wichtig: Wähle beim Erstellen des Projekte **"Erweitert: Keine Anweisungen der obersten Ebene verwenden"** (Engl.: etwas mit "Top-Level Statements") aus.
   1. Verwende das **Template** (siehe unten) und ...
   1. ... Programmiere damit das Spiel Hangman. Schaue, dass alle **Vorgaben** unten erfüllt sind.
   1. **Teste** dein Spiel ausgiebig: Falsche Eingaben machen, Spiel gewinnen, verlieren, ...
   1. Wenn du denkst dass du fertig bist: Gehe die **Checkliste** unten durch. Falls ein Punkt nicht erfüllt ist, verbessere diesen und hake diesen ab. Sobald alle Punkte erfüllt und abgehakt sind ...
   1. ... **Arbeit abgeben:**
      1. Nachricht an Lehrperson in Teams-Chat
      1. inkl. Link zu GitHub-Repo
      1. inkl. abgehakter und unterschriebener Checkliste


**Zeit:** Zwei EFIF-Nachmittage (6 Lektionen), Rest HA

**Vorgaben:**

   * **Template** verwenden und an dieses halten.
   * Code muss **robust** sein: Egal was Benutzer eingibt: Code muss damit klarkommen.
   * Von Player1 eingegebenes Wort (das, welches Player2 erraten muss) muss folgende Bedingung erfüllen:
     * Mind. 3 Buchstsaben
     * Nur ASCII-Grossbuchstaben: 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
     * also keine Umlaute (Ä,Ö,Ü) usw. (É,...), keine Leerschläge
     * Bei unzulässiger Eingabe wird solange aufgefordert, neues einzugeben bis ok
   * Nur GROSSBUCHSTABEN. Player1 & 2 können Kleinbuchstaben eingeben, werden dann aber in Grossbuchstaben umgewandelt.
   * Erraten der Buchstaben (Player2):
     * Wird bereits erratener Buchstabe erraten, zählt dies *nicht* als Fehlversuch. Player2 wird darauf hingewiesen und aufgefordert, andren Buchstaben einzugeben.
     * Auch unzulässige Eingaben (Zahl, Umlaut, Sonderzeichen, ...) zählen nicht als Fehlversuche.



==== Template ====

++++Template (ohne Top-Level Statements)|
<code csharp>
namespace HangMan; // here use name of your project

class Program
{
    // No variable declarations in this area!!
    static void Main(string[] args)
    {
        // Variable declarations allowed here
        while (true)                     // The game repeats until finished by player 1
        {
            // Variable declarations allowed here
            ReadSecretWord();            // Player 1: Enter the secret word to be guessed by player 2
            HangTheMan();                // Screen output for a good start
            while (true)                 // Player 2: Make your guesses
            {
                ReadOneChar();           // Handle input of one char. 
                EvaluateTheSituation();  // Game Logic goes here
                HangTheMan();            // Screen output goes here
            }
            QuitOrRestart(); // Ask if want to quit or start new game
        }
    }

    static void ReadSecretWord() // Modification of method declaration recommended: Add return value and parameters
                                 // If there are rules and constraints on allowed secrets (e.g. no digits), check them in here
    {
        // Variable declarations allowed here
        // Console.Write() etc. allowed here!
    }

    static void ReadOneChar() // Modification of method declaration recommended: Add return value and parameters
                              // If there are rules and constraints on allowed secrets (e.g. no digits), make sure the input is allowed
    {
        // Variable declarations allowed here
        // Console.Write() etc. allowed here!
    }

    static void EvaluateTheSituation() // Modification of method declaration recommended: Add return value and parameters
                                       // In here, evaluate the char entered: Is it part of the secret word?
                                       // Calculate and return the game status (Hit or missed? Where? List and number of missed chars?...)
    {
        // Variable declarations allowed here
        // NO Console.Write() etc. in here!
    }

    static void QuitOrRestart() // Modification of method declaration recommended: Add return value and parameters
                                // If there are rules and constraints on allowed secrets (e.g. no digits), check them in here
    {
        // Variable declarations allowed here
        // Console.Write() etc. allowed here!
    }

    static void HangTheMan() // Modification of method declaration recommended: Add return value and parameters
                             // In here, clear the screen and redraw everything reflecting the actual game status
    {
        // Variable declarations allowed here
        // all Console.Write() etc. go here
    }
}
</code>
++++

++++Template (mit Top-Level Statements)|
<code csharp>
// TEMPLATE FOR TOP-LEVEL STATEMENTS

// Variable declarations allowed here

while (true)                     // The game repeats until finished by player 1
{
    // Variable declarations allowed here
    ReadSecretWord();            // Player 1: Enter the secret word to be guessed by player 2
    HangTheMan();                // Screen output for a good start
    while (true)                 // Player 2: Make your guesses
    {
        ReadOneChar();           // Handle input of one char. 
        EvaluateTheSituation();  // Game Logic goes here
        HangTheMan();            // Screen output goes here
    }
    QuitOrRestart();             // Ask if want to quit or start new game
}

void ReadSecretWord() // Modification of method declaration recommended: Add return value and parameters
                      // If there are rules and constraints on allowed secrets (e.g. no digits), check them in here
{
    // Variable declarations allowed here
    // Console.Write() etc. allowed here!
}

void ReadOneChar() // Modification of method declaration recommended: Add return value and parameters
                   // If there are rules and constraints on allowed secrets (e.g. no digits), make sure the input is allowed
{
    // Variable declarations allowed here
    // Console.Write() etc. allowed here!
}

void EvaluateTheSituation() // Modification of method declaration recommended: Add return value and parameters
                            // In here, evaluate the char entered: Is it part of the secret word?
                            // Calculate and return the game status (Hit or missed? Where? List and number of missed chars?...)
{
    // Variable declarations allowed here
    // NO Console.Write() etc. in here!
}

void QuitOrRestart() // Modification of method declaration recommended: Add return value and parameters
                     // If there are rules and constraints on allowed secrets (e.g. no digits), check them in here
{
    // Variable declarations allowed here
    // Console.Write() etc. allowed here!
}

void HangTheMan() // Modification of method declaration recommended: Add return value and parameters
                  // In here, clear the screen and redraw everything reflecting the actual game status
{
    // Variable declarations allowed here
    // all Console.Write() etc. go here
}
</code>
++++


==== Checklist ====

<HTML>
    <head>
        <meta charset="UTF-8">
        <title>Checklist Hangman</title>
        <style>
/* From extension vscode.github */
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.vscode-dark img[src$=\#gh-light-mode-only],
.vscode-light img[src$=\#gh-dark-mode-only] {
	display: none;
}

</style>
        
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/Microsoft/vscode/extensions/markdown-language-features/media/markdown.css">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/Microsoft/vscode/extensions/markdown-language-features/media/highlight.css">
<style>
            body {
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe WPC', 'Segoe UI', system-ui, 'Ubuntu', 'Droid Sans', sans-serif;
                font-size: 14px;
                line-height: 1.6;
            }
            
            h1 {
                font-size: 16px;
            }
        </style>
        <style>
.task-list-item {
    list-style-type: none;
}

.task-list-item-checkbox {
    margin-left: -20px;
    vertical-align: middle;
    pointer-events: none;
}
</style>
        
    </head>
    <body class="vscode-body vscode-light">
        <h1 id="checklist-hangman">Checklist Hangman</h1>
<ul class="contains-task-list">
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox"> Mein Code beinhaltet <strong>keine globalen Variablen</strong>. Ich habe also <em>keine</em> Variablen <em>ausserhalb</em> der Main-Methode deklariert (dort wo steht 'No variable declarations in this area!!').</li>
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox"> <strong>Model vs. View I:</strong> In meiner gesamten Main-Methode gibt es <em>keinen einzigen Console-Befehl</em> (<code>Console.WriteLine()</code>, <code>Console.ReadLine()</code>, <code>Console.ReadKey()</code>, ... diese gehören nur in die View-Funktionen).</li>
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox"> <strong>Model vs. View II:</strong>  Auch in der anderen Funktion, die zum Model gehört - <code>EvaluateTheSituation()</code> - gibt es keinen einzigen Console-Befehl.</li>
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox"> In meinem Code gibt es <strong>keine unnötigen Abhängigkeiten</strong>: Alle Grössen, die mehrfach verwendet werden, werden <em>genau 1x deklariert</em>. Zum Beispiel wird das Array mit den erlaubten Buchstaben nur in <code>Main()</code> deklariert und dann den anderen Funktionen, falls benötigt, als Argument übergeben.</li>
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox"> Funktionen sollen <strong>minimalen Zugriff</strong> auf Variablen haben: Funktionen sollen nur diejenigen Variablen übergeben werden, die sie auch tatsächlich benötigen. Zum Beispiel sollte der Funktion <code>ReadOneChar(...)</code> die Anzahl Fehlversuche oder verbleibende Leben <em>nicht</em> übergeben werden (falls man eine solche hat), da diese irrelevant für die Funktion ist.</li>
<li class="task-list-item enabled"><input class="task-list-item-checkbox"type="checkbox">Alle Variablen haben <strong>sinnvolle Variablennamen</strong>, unter denen man sich etwas vorstellen kann. Tipp: Kann eine Variable mit F2 einfach umbenennen.</li>
</ul>

    </body>
</HTML>
\\ \\

    

==== Grafische Darstellung ====

Die Anzahl Versuche soll durch den hänging Man graphisch dargestellt werden. Achtung: Falls dir das zu makaber ist, kannst du auch eine fröhlichere Zeichnung anfertigen. Mögliche Alternativen:

   * Schneemann
   * Rakete
   * Blume


HangMan:

{{ :ef_informatik:hangman.png?200 |}}

   1. Definiere dazu eine Funktion, die die Anzahl Versuche entgegen nimmt und die zugehörige Grafik in die Konsole schreibt:
       1. 0 - nur Galgen
       1. 1 - Kopf
       1. 2 - Kopf, Oberkörper
       1. 3 - Kopf, Oberkörper, ein Bein
       1. 4 - Kopf, Oberkörper, beide Beine
       1. 5 - Kopf, Oberkörper, beide Beine, ein Arm
       1. 6 - HangMan
   1. Verbessere und fine-tune nun dein Spiel so, dass es gut funktioniert und hübsch aussieht.