MIDGARD · Multi User Dungeon Alpha 0.1

Kapitel 2: Werkzeuge im Midgard MUD

Jetzt wird’s praktisch: Du erstellst deine erste LPC-Datei, lädst sie als Objekt, erzeugst einen Clone und testest alles Schritt für Schritt – aber korrekt für das Midgard MUD: mit der Lupe.c (Lens/Stack-Tool) und dem MGtool (Xtool).

Weiter zu Kapitel 3

Als Nächstes: Datentypen, Variablen und einfache Logik.

2.1 Ziel dieses Kapitels

Nach diesem Kapitel kannst du:

  • eine neue .c-Datei anlegen und sauber strukturieren
  • verstehen, was Masterobjekt und Clone sind
  • ein Objekt laden und klonen
  • Änderungen zuverlässig aktivieren (Update/Reload)
  • erste Tests durchführen: Funktionen aufrufen, Ergebnisse prüfen
  • die zwei wichtigsten Werkzeugwelten unterscheiden: Lupe.c vs. MGtool

Wir machen alles in kleinen Schritten. Du musst nicht „alles können“ – aber du brauchst einen stabilen Workflow.

2.2 Die zwei wichtigsten Werkzeuge: Lupe.c & MGtool

Lupe.c (Lens-Objekt): Stack-basiert

Die Lupe ist ein Objekt, das dir eine Sammlung von Befehlen gibt, um Objekte zu laden, zu klonen, im Stack zu halten und Funktionen darauf aufzurufen. Das Herzstück ist ein Stack: Manche Befehle pushen Objekte drauf, andere poppen sie wieder runter und arbeiten damit.

Wichtig für Anfänger:

  • Du kannst mehrere Lupe-Kommandos in einer Zeile schreiben (durch Leerzeichen getrennt).
  • Die Anzahl der Leerzeichen ist egal.
  • Wenn ein Argument Leerzeichen oder Punkte enthält, musst du es in "...", '...' oder |...| setzen.
Lupe: Notation (Merken!)

<filename>  kann sein:
  /pfad/objekt          (absolut)
  ~/work/objekt         (relativ zu deinem Home)
  ~name/work/objekt     (Home eines anderen Magiers)

Wenn der Name Punkte oder Leerzeichen hat:
  me."bag 2" inv
  me.'bag 2' inv
  me.|bag 2| inv

MGtool (Xtool): Kommandos mit x...

Das MGtool ist ein mächtiges Werkzeugpaket mit vielen Befehlen wie xload, xclone, xupdate, xcall, xlook, xgrep usw. Es hat außerdem eine History/Quicktype-Funktion (sehr praktisch, sobald du öfter testest).

MGtool: schnelle Orientierung

xhelp
xman xload
xman xclone
xman xupdate
xman xcall

In diesem Kurs nutzen wir beide Tools – aber so, dass du nie durcheinanderkommst: Lupe ist super für „Objekt auf den Stack → untersuchen → Funktion testen“. MGtool ist super für „Alltagsarbeit“ (laden, klonen, updaten, suchen, Skripten).

2.3 Vorbereitung: Arbeitsordner & Dateiname

Wir arbeiten in einem klaren Übungsordner. Falls du ihn noch nicht hast:

Arbeitsordner anlegen

cd
mkdir work
cd work
pwd

Achte auf einfache Dateinamen: Kleinbuchstaben, Zahlen, Unterstrich. Wir nehmen: hello.c.

2.4 Masterobjekt & Clone – die eine Sache, die du wirklich verstehen musst

Eine LPC-Datei ist erst einmal nur Text. Wenn der Driver sie lädt, entsteht ein Objekt im Speicher: das Masterobjekt. Wenn du daraus ein „Exemplar“ brauchst, erzeugst du einen Clone.

Merkschema

~/work/hello.c            = Datei (Quelltext)
hello (master)            = geladener Bauplan im Speicher
hello#12345               = Clone (ein Exemplar)
hello#12346               = Clone (noch ein Exemplar)

Der typische Anfängerfehler ist: „Ich habe die Datei geändert, aber mein Clone macht noch das Alte.“ Das ist normal – denn der Clone ist schon im Speicher. Lösung: Update/Reload oder neu klonen.

2.5 Deine erste Datei: hello.c

Wir bauen ein Minimalobjekt, das zwei Dinge kann: es initialisiert sich und es liefert eine Testausgabe. Zusätzlich bauen wir eine Debug-Abfrage ein, damit du jederzeit prüfen kannst, ob du wirklich die neue Version testest.

~/work/hello.c (Startversion)

#pragma strict_types

int Inited;
int CreateCount;

void create()
{
  Inited = 1;
  CreateCount++;
}

int query_inited()
{
  return Inited;
}

int query_create_count()
{
  return CreateCount;
}

string hello()
{
  return "Hallo! Dein erstes Objekt lebt.\n";
}

Speichern. Fertig. Jetzt testen wir – erst mit der Lupe (Stack), dann mit dem MGtool (X-Kommandos).

2.6 Testen mit der Lupe.c (Stack-Workflow)

Die Lupe arbeitet mit einem Stack. Du „pushst“ ein Objekt auf den Stack und kannst dann Aktionen darauf ausführen. Hier sind die wichtigsten Befehle für den Start:

  • me – pusht dich selbst auf den Stack
  • here – pusht den Raum, in dem du bist
  • ob <file> – lädt und pusht das Objekt (Masterobjekt)
  • new <file> – klont und pusht (und bewegt den Clone in dein Inventory)
  • = – zeigt das Top-of-Stack (TOS)
  • info – detaillierte Infos zum TOS
  • stk – zeigt den ganzen Stack
  • [<function>] – ruft eine Funktion im TOS auf
  • make – zerstört TOS und baut es aus der Datei neu (Update)

Schritt 1: Masterobjekt laden und anschauen

Lupe: hello laden → anzeigen → Infos

ob ~/work/hello
=
info
stk

Du solltest jetzt sehen, dass das Objekt auf dem Stack liegt.

Schritt 2: Funktionen aufrufen (die echten „Tests“)

Lupe: Funktionen im Top-of-Stack aufrufen

ob ~/work/hello [query_inited]
ob ~/work/hello [hello]
ob ~/work/hello [query_create_count]

Erwartung:

  • query_inited → 1
  • hello → dein Text
  • query_create_count → beim Laden typischerweise 1 (bei erneutem Neuaufbau kann sich das ändern)

Schritt 3: Clone erzeugen (damit du ein Exemplar im Inventory hast)

Lupe: Clone erzeugen (landet im Inventory)

new ~/work/hello

Jetzt liegt ein Clone in deinem Inventory. (Je nach MUD-Befehl z.B. i/inv anzeigen.)

Schritt 4: Den Clone auf den Stack holen und testen

Der Trick bei der Lupe ist: Du kannst aus einem bekannten Objekt (z.B. du selbst) Dinge „auswählen“.

Lupe: dein Inventory anzeigen

me inv

Wenn dein neuer Clone z.B. der 4. Gegenstand im Inventory ist, kannst du ihn so auswählen:

Lupe: 4. Objekt aus deinem Inventory auswählen und Funktion rufen

me .4 [hello]

Falls du nicht sicher bist, welches Objekt welche Nummer hat: nutze me inv und/oder info auf dem ausgewählten Objekt.

2.7 Änderungen übernehmen (Update richtig machen)

Jetzt kommt der wichtigste Praxispart. Änderst du den Text in hello(), musst du dafür sorgen, dass dein Testobjekt im Speicher wirklich neu gebaut wird.

Variante A: Masterobjekt neu bauen (Lupe: make)

make zerstört das Top-of-Stack-Objekt und baut es aus der Datei neu. Für Räume ist das extrem praktisch; für Lernobjekte ebenso.

Lupe: Master laden → update

ob ~/work/hello
make
[hello]

Variante B: Neuen Clone erzeugen

Wenn du einen Clone testest, ist der einfachste Weg oft: alten Clone ignorieren, neuen Clone erzeugen.

Lupe: nach Änderung neu klonen

new ~/work/hello

Profi-Tipp für Anfänger: Nutze den Debug-Zähler query_create_count(), um zu sehen, ob du wirklich die neue Instanz hast.

Debug: Bin ich wirklich „neu“?

ob ~/work/hello [query_create_count]

2.8 Dasselbe mit MGtool (Xtool) – der Alltag

Viele Entwickler nutzen im Alltag oft das MGtool, weil es extrem viel kann (History, Pipelines, Grep, Skripte, …). Die konkreten Befehle und Optionen können je nach Version variieren – aber diese „Grundfamilie“ ist typisch:

  • xload – laden
  • xclone – klonen
  • xupdate – updaten
  • xcall – Funktion aufrufen
  • xlook – Objekt/Container ansehen
MGtool: Hilfe zu einem Befehl

xman xload
xman xclone
xman xupdate
xman xcall

Und MGtool hat eine sehr praktische History:

MGtool: History/Quicktype

%!     // History anzeigen
%%     // letzten Befehl erneut ausführen
%12    // Befehl Nummer 12 erneut ausführen
^alt^neu  // letzten Befehl mit Ersetzung erneut ausführen

Für diesen Kurs gilt: Wenn du mit der Lupe sicher bist, wirst du MGtool lieben – aber die Lupe ist der perfekte Einstieg, weil sie das „Objekt-denken“ sehr klar macht.

2.9 Typische Anfängerfehler (und schnelle Lösungen)

„File not found“

Meist falscher Pfad. Nutze pwd, ls und arbeite anfangs lieber mit ~/work/....

„Ich teste noch die alte Version“

Klassiker. Lösung: make (Lupe) oder neu klonen. Nutze query_create_count().

„Compile error“

Meist Syntax: Semikolon vergessen, Klammern falsch, Tippfehler.

Semikolon vergessen (Klassiker)

// falsch
int x = 1

// richtig
int x = 1;

„Runtime error“

Kompiliert, aber zur Laufzeit stimmt etwas nicht (z.B. 0 statt Objekt). Lösung: kleiner testen, Werte abfragen, Zwischenschritte sichtbar machen.

2.10 Mini-Aufgaben (zum Festigen)

  1. Ändere den Text in hello() und aktualisiere sauber mit make oder neuem Clone.
  2. Füge eine Funktion int add(int a, int b) hinzu und rufe sie über die Lupe auf.
  3. Füge eine Variable string Name hinzu, setze sie in create() und gib sie per query_name() zurück.
Beispiel: add-Funktion

int add(int a, int b)
{
  return a + b;
}

Tipp: Wenn du add testen willst, kannst du in der Lupe Argumente mitgeben:

Lupe: Funktionsaufruf mit Argumenten

ob ~/work/hello [add 2 40]

2.11 Checkliste: Der sichere Anfänger-Workflow

Wenn du unsicher bist: mach genau das

  1) pwd / ls (bin ich im richtigen Verzeichnis?)
  2) Datei editieren und speichern
  3) Lupe: ob ~/work/objekt
  4) Lupe: make   (wenn du updaten willst)
  5) Lupe: new ~/work/objekt   (neuen Clone zum Testen)
  6) Tests: [funktion] aufrufen, info/=/stk nutzen

Damit bist du für die nächsten Kapitel stabil aufgestellt. Ab jetzt geht’s mehr um LPC selbst – und weniger um „wo ist meine Datei?!“.

Ausblick

In Kapitel 3 gehen wir in die Sprache: Datentypen, Variablen, Arrays, Mappings – und wie du sie im Midgard-Stil sauber einsetzt (mit Übungen).

Weiter zu Kapitel 3

Jetzt wird’s richtig LPC.