====== Lyx – Objektorientierte Programmierung (OOP) ======

Lyx kombiniert die Performance von Systemprogrammiersprachen mit der Ergonomie moderner OOP-Sprachen. Dabei wird strikt zwischen leichtgewichtigen Strukturen und mächtigen Klassen unterschieden.

===== 1) Structs (Value-Types) =====

Strukturen sind Datengruppierungen, die standardmäßig auf dem Stack liegen. Sie sind ideal für kleine Objekte (Vektoren, Punkte, Farben), bei denen keine Vererbung benötigt wird.

Zuweisung: Erfolgt durch Kopieren des Inhalts (Copy-by-Value).

Methoden: Können Methoden besitzen, unterstützen aber keine Polymorphie.

<code lyx>
type TPoint = struct {
x, y: int64;

fn Move(dx: int64, dy: int64) {
    self.x := self.x + dx;
    self.y := self.y + dy;
}
};
</code>

===== 2) Klassen (Reference-Types) =====

Klassen sind komplexe Objekte, die auf dem Heap verwaltet werden. Sie unterstützen Vererbung, virtuelle Methoden und das Erstellen von Instanzen via new.

==== Definition und Vererbung ====
Alle Klassen stammen standardmäßig von TObject ab, sofern nicht anders angegeben.

<code lyx>
type Entity = class {
var id: int64;
var name: pchar;

// Konstruktor (wird via new aufgerufen)
fn Create(newId: int64, newName: pchar) {
    self.id := newId;
    self.name := newName;
}

fn Describe() {
    PrintStr("Entity: ");
    PrintStr(self.name);
}
};

// Vererbung
type Player = class extends Entity {
var health: int32;

fn Describe() {
    super.Describe(); // Aufruf der Basisklasse
    PrintStr(" (HP: ");
    PrintInt(self.health as int64);
    PrintStr(")");
}
};
</code>

===== 3) Lebenszyklus eines Objekts =====

Da Lyx keinen Garbage Collector hat, muss die Lebensdauer von Klassen-Instanzen manuell gesteuert werden.

^ Aktion ^ Syntax ^ Beschreibung ^
| Erzeugen | var p := new Player(1, "Hero"); | Reserviert Heap-Speicher und ruft Create auf. |
| Nutzen | p.Describe(); | Zugriff auf Felder und Methoden. |
| Prüfen | if (p == null) { ... } | Testet, ob die Referenz gültig ist. |
| Löschen | dispose p; | Ruft (geplant) Destruktor auf und gibt Speicher frei. |

===== 4) Encapsulation (Sichtbarkeit) =====

Lyx nutzt einfache Keywords, um den Zugriff auf Member zu steuern:

pub: Macht ein Feld oder eine Methode von außerhalb der Unit zugänglich.

(Standard): Ohne pub sind Member nur innerhalb der eigenen Unit sichtbar (Internal).

<code lyx>
type Database = class {
pub var ConnectionString: pchar; // Öffentlich
var InternalSocket: int64;      // Privat (nur in dieser Unit)
};
</code>

===== 5) Polymorphie & Type-Casting =====

In Lyx kannst du zur Laufzeit prüfen, ob ein Objekt von einem bestimmten Typ ist, und es sicher umwandeln.

is: Prüft die Typ-Kompatibilität.

as: Führt einen Cast durch (bei Klassen wird die Referenz umgedeutet).

<code lyx>
fn Process(e: Entity) {
if (e is Player) {
let p := e as Player;
p.health := 100;
}
}
</code>