Willkommen im Level Designer von Abitur Elite Code. Dieses Werkzeug ermöglicht es dir, eigene Programmieraufgaben im Stil der hessischen Abiturprüfung (Praktische Informatik) zu erstellen, zu testen und mit anderen zu teilen.

1. Dateisystem & Speicherort
2. Die Benutzeroberfläche
   • Metadaten
   • Das Textfeld "Aufgabe"
   • Das Textfeld "Materialien"
   • UML / Diagramme (PlantUML)
   • Voraussetzungen
3. Code Editoren
   • Starter Code
   • Musterlösung / Test-Code
   • Validierungs-Code (Roslyn)
4. Leitfaden für Abitur-konforme Levels
5. Schritt-für-Schritt: Dein erstes Level

Bevor wir beginnen, ist es wichtig, den Unterschied zwischen den zwei Dateitypen zu verstehen:

• .elitelvldraft: Dies sind Entwürfe. Sie können jederzeit im Designer bearbeitet werden, sind aber nicht "spielbar" (man kann sie nicht im normalen Menü auswählen, um sie zu lösen).
• .elitelvl: Dies sind exportierte Levels. Sie sind schreibgeschützt und können von Nutzern gespielt werden. Ein Export ist nur möglich, wenn der Entwurf den internen Selbsttest im Designer besteht.

Speicherort:
Alle Levels befinden sich im Ordner levels im Verzeichnis der Anwendung.
Um ein Level zu teilen, sende einfach die .elitelvl-Datei an eine andere Person. Diese muss die Datei dann in ihren levels-Ordner legen.

• Level Name: Der Titel des Levels, der in der Auswahl und im Header angezeigt wird.
• Autor: Dein Name oder Pseudonym.

Hier beschreibst du die Aufgabenstellung. Du kannst spezielle Formatierungen verwenden, um den Text übersichtlicher zu gestalten:

• Fetter Text: Umschließe Text mit zwei Sternchen.

  • Code: **Wichtig**
  • Ergebnis: Wichtig

• Highlight (Blau): Umschließe Begriffe mit eckigen Klammern. Ideal für Klassennamen oder Methoden.

  • Code: Implementiere die Klasse [Tier].
  • Ergebnis: Implementiere die Klasse Tier (wird in der App blau dargestellt).

• Code-Block: Umschließe Code mit {| und |}.

  • Code: {|public void Run()|}
  • Ergebnis:

public void Run()

Hier kommen Hinweise, Tipps oder weiterführende Erklärungen hin. Auch hier funktioniert die Formatierung wie bei der Aufgabe. Zusätzlich gibt es das Hinweis-System:

Du kannst einklappbare Hinweise erstellen, um Lösungen nicht sofort zu verraten.

Syntax:

start-hint: Titel des Hinweises
Hier steht der Text, der erst nach dem Ausklappen sichtbar ist.
Du kannst auch [Code] verwenden.
:end-hint

Für Tipps verwende start-tipp statt start-hint:

start-tipp: Ein kleiner Tipp
Verwende eine for-Schleife.
:end-tipp

Jedes Level benötigt in der Regel ein Klassendiagramm. Abitur Elite Code nutzt PlantUML zur Generierung.

• Der Designer fügt automatisch ein Theme hinzu (skinparam backgroundcolor transparent etc.). Du musst dich nicht um das Styling kümmern.
• Du kannst mehrere Reiter für Diagramme anlegen (z.B. Hauptdiagramm und Hilfsdiagramme für Materialien).
• Klicke auf den "Vorschau generieren"-Button (das Zauberstab-Icon), um das Diagramm zu aktualisieren.

Dokumentation zu PlantUML:
Offizielle PlantUML Referenz
Offizielle PlantUML Klassendiagramme Referenz

Du kannst bis zu 8 Voraussetzungen definieren. Diese werden dem Nutzer angezeigt und verlinken auf passende Lernressourcen (Dometrain Kurse und Microsoft Docs).

Der Designer verfügt über drei Code-Fenster. Um diese zu bearbeiten, klicke auf das Pfeil-Icon neben der jeweiligen Überschrift.

Dies ist der Code, den der Spieler zu Beginn des Levels sieht.

• Er sollte das Grundgerüst enthalten (Klassenrümpfe, Methodensignaturen).
• Vermeide es, Lösungen hier schon vorzugeben.

Dieser Code wird niemals exportiert. Er ist nur für dich während der Entwicklung im Designer sichtbar.

• Nutze dieses Feld, um deine Validierungslogik zu testen.
• Schreibe hier eine korrekte Lösung für deine Aufgabe rein.
• Wenn du im Designer auf "Ausführen" klickst, wird dieser Code gegen deine Validierung geprüft.

Dies ist das Herzstück deines Levels. Hier schreibst du C#-Code, der den Code des Spielers analysiert und bewertet.
Die Validierung basiert auf Reflection. Du erhältst das kompilierte Assembly des Spielers und musst prüfen, ob Klassen, Methoden und Rückgabewerte korrekt sind.

Signatur:

private static bool ValidateLevel(Assembly assembly, out string feedback)
{
    // Deine Logik
}

Rückgabewerte:

• true: Das Level gilt als bestanden.
• false: Das Level ist nicht bestanden. Das Programm wirft dann meistens eine Exception mit Details.
• feedback: Eine Nachricht, die dem Nutzer bei Erfolg angezeigt wird.

Wichtiges Konzept:
Da der Code des Spielers erst zur Laufzeit existiert, kannst du nicht einfach new Tier() schreiben (das würde einen Compiler-Fehler geben, da dein Validator die Klasse Tier nicht kennt). Du musst assembly.GetType("Tier") verwenden.

Um Levels zu erstellen, die dem Stil des hessischen Abiturs (Praktische Informatik) entsprechen, beachte bitte folgende Regeln:

1. Java-Notation in Diagrammen: Das Abitur verwendet in Diagrammen Java-Syntax (z.B. String statt string, boolean statt bool, list.add statt list.Add). Deine Aufgabe ist es oft, diese Unterschiede in den "Hinweisen" zu erklären, aber im Diagramm beim Java-Stil zu bleiben.

2. Namenskonventionen:

   • Java-Diagramm: getGewicht()
   • Erwarteter C#-Code: GetGewicht() (PascalCase für Methoden).

3. Progression:

   • Levels sollten ein Thema schrittweise einführen.
   • Verwende am Anfang viel "Händchenhalten" (genaue Anweisungen, viele Hinweise).
   • Gegen Ende einer Sektion (Mini-Exam) sollten weniger Hilfen gegeben werden.

4. Datenkapselung: Getter und Setter werden im Abitur meist explizit gefordert (getVariable()), statt C#-Properties ({ get; set; }) zu nutzen.

5. Listen: Wenn List<T> verwendet wird, muss dies oft als Assoziation im Diagramm dargestellt werden (mit Sternchen * für "viele").

Hier erstellen wir gemeinsam ein einfaches Level: "Der Taschenrechner".
Folge diesen Schritten und kopiere den Code exakt in die entsprechenden Felder im Designer, um ein funktionierendes, exportierbares Level zu erhalten.

Klicke im Level-Auswählen-Menü "Eigene Levels" auf + und gib folgende Daten ein:

• Name: Der einfache Rechner
• Autor: (Dein Name)

Gehe in den Level Designer des neu erzeugte Level-Entwurfs "Der einfache Rechner (Entwurf)" mit ✎.
Kopiere dann folgenden Text in das Feld Aufgabe:

Erstelle eine Klasse [Rechner], die grundlegende mathematische Operationen durchführen kann.

Implementiere die Methode [Addiere(int a, int b)], die die Summe der beiden Zahlen zurückgibt.

Kopiere diesen Text in das Feld Materialien:

start-hint: Wie addiert man?
Nutze den [+] Operator.
Beispiel: {|return a + b;|}
:end-hint

Füge diesen Code in das Feld Haupt bei "UML/Diagramme (PlantUML)" ein und klicke auf den Vorschau-Button (das kleine Zauberstab-Icon über dem Textfeld):

@startuml
class Rechner {
  + addiere(a : int, b : int) : int
}
@enduml

Klicke auf den Pfeil bei Starter Code (dies öffnet den Editor). Füge dort diesen Code ein, damit der Spieler nicht bei Null anfangen muss:

public class Rechner
{
    // Hier Code implementieren
}

Klicke auf den Pfeil bei Musterlösung / Test-Code. Füge hier die korrekte Lösung ein. Dieser Code wird gleich verwendet, um zu testen, ob deine Validierung funktioniert:

public class Rechner
{
    public int Addiere(int a, int b)
    {
        return a + b;
    }
}

Das ist der wichtigste Teil. Klicke auf den Pfeil bei Validierungs-Code. Hier schreiben wir das Programm, das die Lösung des Spielers prüft.

Kopiere diesen kompletten Block:

private static bool ValidateLevel(Assembly assembly, out string feedback)
{
    // 1. Suche nach der Klasse "Rechner"
    Type t = assembly.GetType("Rechner");
    if (t == null) 
    {
        throw new Exception("Die Klasse 'Rechner' wurde nicht gefunden. Hast du den Namen korrekt geschrieben?");
    }

    // 2. Erstelle eine Instanz der Klasse (ruft den Konstruktor auf)
    object instance = Activator.CreateInstance(t);

    // 3. Suche nach der Methode "Addiere"
    MethodInfo m = t.GetMethod("Addiere");
    if (m == null) 
    {
        throw new Exception("Die Methode 'Addiere' fehlt in der Klasse Rechner.");
    }

    // 4. Teste die Methode mit Werten (5 + 5)
    // Invoke ruft die Methode auf der Instanz auf. Das Array sind die Parameter (a, b).
    object resultObj = m.Invoke(instance, new object[] { 5, 5 });
    
    // Prüfe das Ergebnis
    if (resultObj is int result)
    {
        if (result == 10)
        {
            feedback = "Super! 5 + 5 ist korrekt 10.";
            return true; // Test bestanden
        }
        else
        {
            throw new Exception($"Falsches Ergebnis. Erwartet: 10, Erhalten: {result}");
        }
    }
    
    throw new Exception("Die Methode gibt kein 'int' zurück.");
}

1. Gehe sicher, dass du im Musterlösung / Test-Code Fenster (Schritt 6) bist oder es zumindest befüllt hast.
2. Klicke auf den großen grünen ▶ AUSFÜHREN Button oben rechts.
3. Die Konsole sollte jetzt grün anzeigen: ✓ DESIGNER TEST BESTANDEN.
4. Der Button Exportieren (grün, oben links im Designer-Tab) ist jetzt aktiv. Klicke darauf.
5. Fertig! Du hast eine .elitelvl Datei im levels-Ordner erstellt, die du jetzt verschicken kannst.

Falls du die fertigen Beispiel-Dateien direkt verwenden möchtest:

• Der einfache Rechner.elitelvl - Die exportierte, spielbare Version
• Der einfache Rechner.elitelvldraft - Die Entwurfs-Datei zum Bearbeiten im Designer

Lege die heruntergeladenen Dateien einfach in deinen levels-Ordner (neben der .exe, wenn keiner existiert erstelle diesen selbst).