DLL's benutzen

In Fällen, in denen dir die Funktionalität von GML nicht ausreicht, kannst du die Möglichkeiten nutzen, sie mit Plug-Ins zu erweitern. Ein Plug-in hat die Form einer DLL("Dynamic Link Library"). In einer solchen DLL kann man Funktionen definieren. Diese Funktionen können in jeder Programmiersprache programmiert werden, in der man DLLs erstellen kann(z.B.C/C++, Delphi usw.). Allerdings solltest du dazu schon einige Programmierkenntnisse haben. Plug-In Funktionen müssen ein bestimmtes Format haben. Sie können 0 bis 11 Argumente enthalten, von denen jedes entweder eine reelle Zahl (double in C) oder ein null-terminierter String sein kann (Momentan sind für mehr als 4 Argumente nur reelle Zahlen unterstützt). Die Funktionen können entweder eine reelle Zahl oder einen null-terminierten String zurückgeben.

In Delphi erstellst du eine DLL indem du zuerst im Menü Datei Neu und dann DLL auswählst. Hier ist ein Beispiel einer in Delphi erstellten DLL, die du in Game Maker benutzen kannst. (Beachte, dass dies Delphi Code ist, kein GML Code!)

library MyDLL;

uses SysUtils, Classes;

function MyMin(x,y:double):double;  cdecl;
begin
  if x<y then Result := x else Result := y;
end;

var res : array[0..1024] of char;

function DoubleString(str:PChar):PChar; cdecl;
begin
  StrCopy(res,str);
  StrCat(res,str);
  Result := res;
end;

exports MyMin, DoubleString;

begin
end.

Diese DLL definiert zwei Funktionen: MyMin gibt die kleine von zwei reellen Zahlen zurück und DoubleString hängt einen String an sich selbst an. Beachte, dass du vorsichtig mit dem Speicher umgehen solltest. Deshalb habe ich den resultierenden Wert als global String definiert. Außerdem wird hier die cdecl Aufrufkonvention verwendet. Du kannst entweder cdecl- oder stdcall-Aufrufkonventionen verwenden. Wenn du die DLL in Delphi kompilierst erhältst du eine Datei MyDLL.DLL. Diese Datei muss ins Arbeitsverzeichnis deines Spiels (oder an irgendeinen anderen Ort, an dem sie von Windows gefunden werden kann).

Um diese DLL in Game Maker nutzen zu können, musst du zuerst die externen Funktionen definieren, die du benutzen willst und welche Art von Argumenten verwendet werden. Dafür gibt es folgende Funktion in GML:

external_define(dll,name,calltype,restype,argnumb,arg1type,arg2type, ...) Definiert eine externe Funktion. dll ist der Name der DLL-Datei, name ist der Name der Funktionen. calltype ist die genutzte Aufruf-Konvention (nutze hierfür entweder dll_cdecl oder dll_stdcall). restype ist der Typ des Rückgabewerts(ty_real oder ty_string). argnumb ist die Anzahl der Argumente (0-11). Als nächstes musst du für jedes Argument dessen Typ festlegen (wieder ty_real oder ty_string). Sind mehr als 4 Argumente vorhanden, dann müssen diese alle vom Typ ty_real sein.

Diese Funktion liefert die ID der externen Funktion und muss für das Aufrufen verwendet werden. Im oberen Beispiel müsste am Anfang des Spiels folgender GML Code stehen:

{
  global.mmm = external_define('MYOWN.DLL','MyMin',dll_cdecl,
                                     ty_real,2,ty_real,ty_real);
  global.ddd = external_define('MYOWN.DLL','DoubleString',dll_cdecl,
                                     ty_string,1,ty_string);
}

Nun, kannst du die Funktionen, immer wenn du sie brauchst, mit folgender Funktion aufrufen:

external_call(id, arg1, arg2, ...) Ruft die externe Funktion mit der gegebenen ID und den gegebenen Argumenten auf. Die richtige Anzahl der Argumente und deren richtiger Typ(real oder string) müssen angegeben werden. Die Funktion gibt das Ergebnis der externen Funktion zurück.

Also kann man beispielsweise schreiben:

{
  aaa = external_call(global.mmm,x,y);
  sss = external_call(global.ddd,'Hello');
}

Wenn die DLL nicht mehr gebraucht wird, sollte man sie besser freigeben.

external_free(dll) Gibt die DLL mit dem gegebenen Namen frei. Das ist dann erforderlich, wenn das Spiel die DLL entfernen soll. Solange die DLL nicht freigegeben ist, kann sie auch nicht entfernt werden. Am besten sollte man das beispielsweise in einem Event machen, welches das Spiel beendet.

Du wirst dich vielleicht wundern, wie du eine DLL-Funktion schreiben kannst, die etwas im Spiel bewirkt. Zum Beispiel könntest du eine DLL schreiben wollen, die Instanzen eines Objektes in deinem Spiel erstellt. Der einfachste Weg ist deine DLL einen String zurückgeben zu lassen, der ein Stück GML Code enthält. Dieser String kann dann mit dieser Funktion ausgeführt werden:

execute_string(str) Führt den String als GML Code aus.

Alternativ kannst du die DLL eine Datei mit einem Script erstellen lassen, das dann ausgeführt werden kann (diese Funktion kann auch dazu benutzt werden, das Verhalten eines Spieles nachträglich zu beeinflussen).

execute_file(fname) Führt die Datei als GML Code aus.

Nun kannst du eine externe Funktion aufrufen und dann den resultierenden String z.B. folgendermaßen ausführen:

{
  ccc = external_call(global.ddd,x,y);
  execute_string(ccc);
}

In manchen seltenen Fällen, kann es sein, dass deine DLL den Handle des Hauptfensters des Spiels benötigt. Diesen kann man durch folgenden Code erhalten und dann an die DLL weitergeben:

window_handle() Gibt den Handle für das Spielfenster zurück

Beachte, dass DLLs im Secure-Mode nicht genutzt werden können.

Externe DLLs zu benutzen ist ein mächtiges Instrument. Aber nutze es bloss, wenn du genau weißt was du tust.