[Release] MTA Class Library

Häufig benötigt man nur eine Klasse für einen Elementtyp. Ein gutes Beispiel dafür ist eine Spielerklasse. Damit man sich das enew bei onPlayerConnect sparen kann, gibt es registerElementClass(elementTyp, klasse).

PlayerClass = {}
function PlayerClass:hallo()
	outputChatBox("Hallo! Ich bin "..self:getName(), root)
end


function PlayerClass:getName()
	return getPlayerName(self)
end


registerElementClass("player", PlayerClass)


local player = getRandomPlayer()


player:hallo() -- output: "Hallo! Ich bin [name]"

Die Funktionen new und delete sind ähnlich ihrem C++ Equivalent. new(Klasse, Argument1, Argument2...) erzeugt eine neue Instanz der Klasse und ruft die Klassenfunktion Klasse:constructor mit den übergebenen Parametern auf. Weiterhin ruft new alle "derived_constructor"-Funktionen in Klassen auf, von denen die Klasse erbt.
delete(Instanz/Element) ruft derzeit nur die Klassenfunktion Klasse:destructor mit den übergebenen Parametern auf. Ein "derived_destructor" ist derzeit nicht implementiert, aber ist geplant. Ein derived_destructor ist ähnlich wie der derived_constructor ebenfalls verfügbar.

Klasse = {}


function Klasse:constructor(paramA)
	outputDebugString("Created Instance with "..tostring(paramA))
end


function Klasse:destructor(paramA)
	outputDebugString("Destroyed Instance with "..tostring(paramA))
end


local instance = new(Klasse, 1234)


delete(instance, "Hallo")

Die Funktion inherit(from[, what = {}]) ermöglicht simple Vererbung.

Basisklasse = {}
function Basisklasse:test()
	print("hallo")
end


function Basisklasse:testZwei()
	print("hallo zwei")
end


Klasse = inherit(Basisklasse, {}) -- {} könnte hier weggelassen werden
function Klasse:test()
	print("Abgeleitete Klasse")
end


local instance = new(Klasse)
instance:test() -- "Abgeleitete Klasse"
instance:testZwei() -- "hallo zwei"

Analog ist auch Mehrfachvererbung möglich, indem mehrmals inherit angewendet wird.

BasisklasseA = {}
function BasisklasseA:FuncA()
	print("BasisklasseA")
end


BasisklasseB = {}
function BasisklasseB:FuncB()
	print("BasisklasseB")
end


Klasse = {}
inherit(BasisklasseA, Klasse)
inherit(BasisklasseB, Klasse)


local instance = new(Klasse)
instance:FuncA() -- "BasisklasseA"
instance:FuncB() -- "BasisklasseB"

Zusätzlich gibt es folgende Funktionen zur Hilfe bei der Handhabung von Vererbungen
table super(instance/class)
Gibt eine Table der Basisklassen zurück, von denen die Klasse erbt. Wird eine Instanz übergeben, so wird die Klasse der Instanz zurückgegeben.

bool instanceof(instance, class, direct = false)
Gibt zurück, ob instance von class erbt (bzw. eine Instanz von class ist). Ist direct = true, dann wird nur geprüft ob instance direkt und ohne weitere Vererbung von class erbt.

Hinter der Funktion addChangeHandler(instance, key, func) verbirgt sich eine extrem nützliche Funktion, die es euch ermöglicht eine Funktion auszuführen, wenn sich ein Wert in einer Table ändert.

Wollt ihr beispielsweise, dass sobald sich der "score" Wert einer table ändert, dieser in der MySQL Datenbank gesichert wird, so ist dies folgendermaßen möglich:

function broadcastScore(self, newvalue)
	outputChatBox("Der Score ist jetzt "..tostring(newvalue))
end


local tab = {}
addChangeHandler(tab, "score", broadcastScore)


tab.score = 12 -- "Der Score ist jetzt 12"

Gibt der Changehandler etwas anderes, als "nil" zurück, so wird der Wert auf den Rückgabewert geändert. Dadurch lässt sich beispielsweise ein Key als Read-Only festlegen:

function readOnlyScore(self, newvalue)
	-- Der alte Score wird zurückgegeben, daher wird newvalue ignoriert
	return self.score
end


local tab = {}
tab.score = 12
 addChangeHandler(tab, "score", readOnlyScore)


tab.score = 15 


print(tab.score) -- 12