DLL's gebruiken

In de gevallen waar de mogelijkheden van GML niet genoeg zijn voor jouw wensen, kun je de mogelijkheden uitbreiden door plug-ins te gebruiken. Een plug-in in de vorm van een DLL bestand (een Dynamic Link Library). In zo'n DLL bestand kun je functies definiëren. Zulke functies kunnen worden geprogrammeerd in elke programmeertaal die het maken van DLL's ondersteunt (bijv. Delphi, C, C++, enz.) Je moet wel een goede programmeur zijn om dit te kunnen doen. Plug-in functies moeten een bepaald formaat hebben. Ze kunnen tussen de 0 en 11 argumenten hebben, elk kan een getal (double in C) of een tekenreeks. (Bij meer dan 4 argumenten, worden op het moment alleen getallen ondersteund.) Ze moeten ook een getal of een tekenreeks teruggeven.

In Delphi kun je een DLL maken door eerst New in het menu File te kiezen en dan DLL te selecteren. Hier is een voorbeeld van een DLL die je kunt gebruiken in Game Maker, geschreven in Delphi. (Merk op dat dit Delphi code is, geen 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.

Deze DLL definieert twee functies: MyMin die twee getalargumenten neemt en het minimum van de twee teruggeeft, en DoubleString die de tekenreeks verdubbelt. Merk op dat je voorzichtig moet zijn met het beheren van geheugen. Daarom heb ik de resulterende tekenreeks globaal gedeclareerd. Let ook op het gebruik van de cdecl calling convention. Je kunt kiezen uit de cdecl en de stdcall calling convention. Als je eenmaal de DLL in Delphi hebt gebouwd zul je een bestand MyDLL.DLL krijgen. Dit bestand moet worden geplaatst in de werkmap van je spel. (Of elke andere plaats waar Windows het kan vinden.)

Om deze DLL in Game Maker te gebruiken moet je eerst de externe functies specificeren die je wilt gebruiken en welke typen argumenten ze gebruiken. Hiervoor is de volgende functie in GML:

external_define(dll, naam, calltype, restype, argaant, arg1type, arg2type, ...) Definieert een externe functie. dll is de naam van het dll bestand. naam is de naam van de functies. calltype is de gebruikte calling convention. Gebruik hiervoor dll_cdecl of dll_stdcall. restype is het type resultaat. Gebruik hiervoor ty_real of ty_string. argaant is het aantal argumenten (0-11). Vervolgens moet je voor elk argument het type specificeren. Gebruik hiervoor opnieuw ty_real of ty_string. Als er meer dan 4 argumenten zijn moeten ze allemaal van het type ty_real zijn.

Deze functie geeft het id van de externe functie, die moet worden gebruikt om het op te roepen. Dus in bovenstaande voorbeeld, zou je aan het begin van het spel de volgende GML code willen gebruiken:

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

Nu gebruik je voor elke situatie waarin je de functies moet oproepen de volgende functie:

external_call(id, arg1, arg2, ...) Roept de externe functie op met het gegeven id, en de gegeven argumenten. Je moet het correcte aantal argumenten van het correcte type (real of string) geven. De functie geeft het resultaat van de externe functie.

Dus zou je bijvoorbeeld schrijven:

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

Als je de DLL niet meer hoeft te gebruiken, kun je hem beter uit het werkgeheugen halen.

external_free(dll) Haalt de DLL met de gegeven naam uit het werkgeheugen. Dit is onder andere noodzakelijk als het spel de DLL zou moeten verwijderen. Zolang de DLL niet uit het werkgeheugen is gehaald kan hij niet worden verwijderd. Je kunt dit bijv. het beste doen in een Game End event.

Je vraagt je misschien af hoe je een functie in een DLL maakt die iets doet in het spel. Bijvoorbeeld, misschien wil je een DLL maken die object instanties toevoegt aan het spel. De eenvoudigste manier is om je DLL functie een tekenreeks terug te laten geven die een stukje GML code bevat. De tekenreeks die het stukje GML bevat kan worden uitgevoerd door de volgende GML functie te gebruiken

execute_string(tkr) Voert het stukje code in de tekenreeks tkr uit.

Als alternatief kun je je DLL een bestand laten maken met een script dat kan worden uitgevoerd (deze functie kan ook worden gebruikt om later het gedrag van een spel aan te passen).

execute_file(bnaam) Voert het stukje code uit in het bestand.

Nu kun je een externe functie oproepen en dan de resulterende tekenreeks uitvoeren, bijv. als volgt:

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

In sommige rare situaties moet je DLL misschien de handle van het algemene graphics venster van het spel. Dit kan worden verkregen met de volgende functie en kan dan worden doorgegeven aan de DLL:

window_handle() Geeft het venster handle van het algemene venster.

Merk op dat DLL's niet kunnen worden gebruikt in secure mode.

Het gebruik van externe DLL's is een extreem krachtig mechanisme. Maar gebruik het alsjeblieft alleen als je weet wat je aan het doen bent.