Spellen ontwerpen met Game Maker

versie 4.1 (12 januari 2002)

Mark Overmars

Vertaling:
Piet Geelen
Marja ter Wal
Jaap Mulders
Jos Mars
Gerard Heijmeriks
Inhoudsopgave
Hoofdstuk 1 Dus jij wilt je eigen computerspellen maken..............................................5
Hoofdstuk 2 Installatie.................................................................................................7
Hoofdstuk 3 Het globale idee......................................................................................9
Hoofdstuk 4 Een spelvoorbeeld nader bekeken......................................................11
Hoofdstuk 5 De algemene gebruikersinterface........................................................13
5.1 File menu........................................................................................................13
5.2 Edit menu.......................................................................................................14
5.3 Add menu.......................................................................................................15
5.4 Window menu.................................................................................................15
5.5 Help menu......................................................................................................16
5.6 De resource explorer (bronnen/voorwerpen verkenner).................................16
Hoofdstuk 6 Het definiëren van sprites....................................................................17
Hoofdstuk 7 Bewegingen en muziek........................................................................18
Hoofdstuk 8 Achtergronden......................................................................................19
Hoofdstuk 9 Het definiëren van objecten.................................................................20
Hoofdstuk 10 Gebeurtenissen (Events)......................................................................22
Hoofdstuk 11 Acties.....................................................................................................27
11.1 Bewegings acties............................................................................................27
11.2 Object gerelateerde acties..............................................................................30
11.3 Diverse acties.................................................................................................31
11.4 Vragen............................................................................................................ 33
11.5 Teken acties...................................................................................................36
11.6 Code gerelateerde acties................................................................................37
11.7 Expressies en variabelen gebruiken...............................................................38
Hoofdstuk 12 Het maken van rooms...........................................................................39
Hoofdstuk 13 Meer over sprites..................................................................................42
13.1 Sprites editen..................................................................................................42
13.2 Individuele subplaatjes editen.........................................................................47
13.3 Geavanceerde sprite instellingen....................................................................48
Hoofdstuk 14 Meer over geluiden en muziek.............................................................50
Hoofdstuk 15 Meer over achtergronden.....................................................................51
15.1 Getegelde achtergronden maken...................................................................51
Hoofdstuk 16 Meer over objecten...............................................................................54
16.1 Depth.............................................................................................................. 54
16.2 Persistent objects...........................................................................................54
16.3 Parents........................................................................................................... 54
16.4 Masks............................................................................................................. 55
Hoofdstuk 17 Meer over rooms...................................................................................56
Hoofdstuk 18 Scripts...................................................................................................58
Hoofdstuk 19 Spel informatie......................................................................................60
Hoofdstuk 20 Spel opties.............................................................................................61
20.1 Graphics opties...............................................................................................61
20.2 Key opties.......................................................................................................62

2
 20.3 Interaction opties............................................................................................62
20.4 Score opties....................................................................................................63
20.5 Loading opties................................................................................................63
Hoofdstuk 21 Snelheidsoverwegingen.......................................................................64
Hoofdstuk 22 Je spel verspreiden..............................................................................65
Hoofdstuk 23 De Game Maker Language (GML)........................................................66
23.1 Een programma..............................................................................................66
23.2 Variabelen......................................................................................................66
23.3 Toewijzingen...................................................................................................67
23.4 Expressies......................................................................................................67
23.5 Extra variabelen..............................................................................................67
23.6 Variabelen aanroepen in andere instanties.....................................................68
23.7 Arrays............................................................................................................. 69
23.8 If statement.....................................................................................................70
23.9 Repeat statement...........................................................................................70
23.10 While statement..........................................................................................70
23.11 For statement..............................................................................................71
23.12 Exit statement.............................................................................................71
23.13 Functie........................................................................................................71
23.14 Scripts.........................................................................................................72
23.15 With constructies........................................................................................72
23.16 Commentaar...............................................................................................73
23.17 Pascal stijl...................................................................................................74
23.18 Functies en variabelen in GML...................................................................74
Hoofdstuk 24 Dingen berekenen.................................................................................75
24.1 Constanten.....................................................................................................75
24.2 Reële waarde functies....................................................................................75
24.3 String handling functies..................................................................................76
Hoofdstuk 25 GML: Het spelverloop...........................................................................77
25.1 Verplaatsen....................................................................................................77
25.2 Instanties........................................................................................................78
25.3 Timing............................................................................................................. 80
25.4 Kamers en score............................................................................................81
25.5 Events genereren...........................................................................................82
25.6 Diverse functies..............................................................................................84
Hoofdstuk 26 GML: Interactie met de gebruiker........................................................85
26.1 Joystick ondersteuning...................................................................................87
Hoofdstuk 27 GML: Spel graphics..............................................................................88
27.1 Venster en cursor...........................................................................................88
27.2 Sprites en plaatjes..........................................................................................89
27.3 Achtergronden................................................................................................91
27.4 Functies die gebruikt worden voor tekenen....................................................93
27.5 Views.............................................................................................................. 96
Hoofdstuk 28 Geluid en muziek..................................................................................98
Hoofdstuk 29 GML: Splash screens, highscores, en andere popup vensters......101
Hoofdstuk 30 GML: Files, registry, and executing programs.................................103
Hoofdstuk 31 GML: Multiplayer spellen....................................................................105

3
 31.1 Een verbinding tot stand brengen.................................................................105
31.2 Het maken en deelnemen aan sessies.........................................................106
31.3 Spelers......................................................................................................... 107
31.4 Shared data..................................................................................................108
31.5 Berichten......................................................................................................108
Hoofdstuk 32 GML: Het gebruik van DLL's..............................................................110

4
Hoofdstuk 1 Dus jij wilt je eigen computerspellen
maken.
Het spelen van computerspellen is leuk. Maar wat eigenlijk veel leuker is, is het maken
van je eigen computerspellen en anderen die laten spelen. Helaas is het maken van
computerspellen niet eenvoudig. Commerciële computerspellen zoals je ze
tegenwoordig kunt kopen hebben een ontwikkeltijd van ongeveer 3 jaar waarmee een
ontwikkelteam van tussen de 10 en 50 personen betrokken is. De beschikbare
budgetten bedragen al gauw in de miljoenen dollars. Bovendien zijn deze mensen ook
nog eens bijzonder goed op hun vakgebied: programmeurs, ontwerpers, geluidstechnici,
enz.

Betekent dit nu dat het onmogelijk is om je eigen computerspelen te maken? Gelukkig

niet. Natuurlijk moet je niet verwachten dat je je eigen “Quake” of “Age of Empires” in
een paar weken kunt maken. Maar dat is ook helemaal niet nodig. Een stuk
eenvoudigere spellen dan “Tetris”, “pacman”, Space Invaders”, enz. zijn ook best aardig
om te spelen en veel eenvoudiger om te maken. Helaas vereisen zij ook nog goede
kennis van programmeren om met grafisch werk, geluid, interacties enz. te kunnen
omgaan.

Maar nu bestaat het programma Game Maker. Dat is ontwikkeld om het voor jou een
stuk eenvoudiger te maken om zulke spellen te maken. Er komt zo goed als geen
programmeerwerk meer bij kijken. Een intuïtieve en eenvoudig te gebruiken interface
waarin je alles met verplaatsen in een scherm kunt bereiken, maakt het mogelijk om snel
je spellen te kunnen maken. Je kunt afbeeldingen importeren of zelf maken, evenals
sprites (animated gifs), geluiden, ruimtes enz. en ze daarna meteen gebruiken. Je kunt
eenvoudig je objecten definiëren die in een spel voorkomen en er gedrag aan
toekennen. Bovendien is het mogelijk spellen te ontwikkelen waarin meerdere levels
voorkomen met verschillende moeilijkheidsgraden. Indien je zelf alles in de hand wilt
houden is dat ook mogelijk; het programma bevat namelijk een eigen programmeertaal,
die jou de mogelijkheid biedt om je programma volledig naar jouw hand te zetten.
Daarvoor moet je toch wel enige programmeerkennis hebben.

Game Maker is vooral bedoeld om tweedimensionale spellen mee te ontwikkelen. Dus

geen driedimensionale spellen als “Quake”. Maar laat dat vooral geen teleurstelling zijn.
Veel grote spellen zoals Age of Empires”, de “Command and Conquer”-serie en
“Diabolo”gebruiken tweedimensionale sprite-technieken, hoewel ze erg driedimensionaal
lijken. Bovendien is het maken van tweedimensionale spellen eenvoudiger en sneller.

Game Maker is freeware. Er zijn geen beperkingen op de spellen die je ermee maakt.
Je zou ze eventueel kunnen verkopen. Kijk maar eens naar de ingesloten licentie als je
het programma hebt gedownload.

In deze handleiding wordt alles uitgelegd wat je moet weten over Game Maker en hoe
je ermee spellen kunt maken. Je moet je echter wel realiseren dat het maken van
spellen niet zomaar iets is. Er zijn bij het maken van spellen echt een aantal dingen
belangrijk: wat voor soort spel wordt het, hoe moet de omgeving eruit zien, welke figuren
spelen een rol, welke acties komen er in voor, welke geluiden voeg je er aan toe, enz.

5
Begin eerst met het ontwerpen van een zeer eenvoudig spelletje om inzicht te krijgen
hoe het werkt. Je zult merken dat het veel plezier oplevert om spellen te maken.

Bekijk eens de volgende website:

http://www.cs.uu.nl/~markov/gmaker/index.html

daar zul je veel voorbeelden, ideeën en hulp kunnen vinden. Bovendien is er een forum
waaraan je kunt deelnemen. Na flink wat oefenen wordt jij misschien zelf een super
spelontwikkelaar.

6
Hoofdstuk 2 Installatie
Waarschijnlijk heb je het programma al geïnstalleerd, maar als dat nog niet het geval is,
kun je hier de installatieprocedure volgen.
Klik na het downloaden op gmaker.exe. Volg de instructies die op het scherm
verschijnen. Je kunt het programma overal op je PC installeren, maar toch kun je het
beste de standaard installatiesuggesties volgen. Als de installatie eenmaal voltooid is,
zul je in het startmenu een nieuwe programmagroep aantreffen waar je Game Maker
mee kunt starten en de documentatie kunt opvragen.

Naast GameMaker is er ook het programma GameRunner geïnstalleerd. Dit programma

wordt gebruikt om de gemaakte spellen te kunnen runnen. Het wordt ook gebruikt als je
stand-alone versies van je spelletjes maakt. De documentatie wordt geïnstalleerd samen
met de help-file.

Binnen de installatiemap ( standaard C:\Program Files\Game_maker4\) zijn een

aantal andere mappen aangemaakt:
 examples: bevat een aantal voorbeelden van spellen die je kunt gebruiken en
veranderen, bedoeld als oefeningen.
 sprites: bevat een verzameling freeware (animated) sprites die in je spellen
gebruikt mogen worden. De volgende personen hebben sprites ter beschikking
gesteld:
o Primalmania, zie http://primalmania.fateback.com/.
o Morphosis, zie http://www.geocities.com/morphosisgames/.
o Billy McQuown.
 backgrounds: bevat een aantal freeware achtergrondafbeeldingen die je in je
spellen kunt gebruiken.
 sounds: bevat een aantal freeware geluidseffecten die je in je spellen kunt
gebruiken.
 tiles: bevat een aantal tile sets die je kunt gebruiken om achtergronden mee
te maken. (zie Error: Reference source not found). De volgende tiles sets
werden door anderen gemaakt:
o platform1_16x16.bmp en platform2_16x16.bmp zijn tile sets voor
platformspellen. Ari Feldman heeft het copyright. Kijk op de website
http://www.arifeldman.com/free/spritelib.html voor meer informatie.
o rpg1_24x24.bmp en rpg2_24x24.bmp zijn nuttig voor strategische
spellen. Zij bevatten een beperkte versie van de sets die gemaakt zijn
door Hermann Hillmann als onderdeel van de charpack. Kijk op de
charpack website. http://www.vbexplorer.com/charpack1.asp voor meer
informatie.
o km_16x16.bmp, pk_16x16.bmp en ps_16x16.bmp werden ontworpen
door e.m.b.u. Kijk op http://www.embu.cjb.net voor de voorwaarden en
eventuele andere tile sets.
 scripts: bevat enige waardevolle scripts (zie Hoofdstuk 18).

De sprites, achtergronden, geluiden en tiles vormen geen direct onderdeel van Game
Maker, maar zijn gehaald uit freeware verzamelingen.

7
Om Game Maker te kunnen gebruiken heb je een moderne Pentium PC nodig met
minimaal Windows95 of hoger. Het vereist een beeldschermresolutie van minimaal
800x600 en 65000(16-bit) kleuren. Bovendien moet DirectX op je PC zijn geïnstalleerd.
Om spellen te maken en te testen moet er minimaal 32MB RAM aanwezig zijn, liefst
meer. Om alleen maar spelletjes te spelen kan ook met minder RAM-geheugen worden
volstaan. Wel hangt het van het type spel af hoeveel geheugen nodig blijkt te zijn.

8
Hoofdstuk 3 Het globale idee
Alvorens te duiken in de mogelijkheden van GameMaker is het goed om eerst een idee
te krijgen wat het globale idee achter dit programma is. Spellen die gemaakt zijn met
Game Maker spelen zich af in één of meer rooms. (Rooms zijn vlak, niet 3D, maar zij
kunnen er 3D-achtig uitzien). In deze rooms plaats je objecten, die je met het
programma kunt definiëren. Typische objecten zijn: muren, bewegende ballen,
monsters, een hoofdfiguur, enz. Sommige objecten zoals muren staan in de room en
doen verder niets. Andere objecten zoals een hoofdfiguur kunnen bewegen door de
room en reageren op input van de speler (toetsenbord, muis, joystick) en op andere
objecten. Bijvoorbeeld, als de hoofdfiguur een monster ontmoet kan dat zijn dood
betekenen. Objecten zijn de belangrijkste onderdelen van de spellen die met Game
Maker worden gemaakt. Laten we daarom op objecten iets dieper ingaan.

Allereerst hebben objecten een uiterlijk (afbeelding) nodig om ze zichtbaar te maken op

het beeldscherm. Zulke afbeeldingen noemen we sprites. Een sprite is soms een enkele
afbeelding maar het kan ook voorkomen dat hij bestaat uit meerdere afbeeldingen na
elkaar (animated gif). Dan lijkt het bijvoorbeeld of een persoon loopt, een bal draait, een
ruimtevaartuig explodeert, enz. Tijdens het spel kan de sprite van een object
veranderen. (een persoon ziet er anders uit als hij naar links of naar rechts loopt) In
Game Maker kun je je eigen sprites maken of je kunt ze in het spel halen door kant en
klare files te openen.

Met objecten gebeuren bepaalde dingen. Deze gebeurtenissen noemen we events.

Objecten kunnen bepaalde actions (handelingen) verrichten als een event plaatsvindt.
Er kan een groot aantal events plaatsvinden en er is een groot aantal handelingen die
verricht kunnen worden door de objecten. Bijvoorbeeld: er is een creation event als een
object wordt gemaakt. (Om preciezer te zijn: als een instantie van een object wordt
gemaakt; er kunnen meerdere instanties van hetzelfde object zijn). Als een bal wordt
gemaakt kun je die bal een beweging meegeven zodat hij begint te bewegen als hij
gemaakt wordt. Als twee objecten elkaar treffen treedt er een collision event (botsing)
op. In zo’n geval kun je ervoor zorgen dat de bal stopt of een beweging krijgt in een
andere richting, bijvoorbeeld de tegenovergestelde richting. Je kunt bij die botsing ervoor
zorgen dat er een geluid wordt geproduceerd. In Game Maker bestaat de mogelijkheid
om geluiden toe te voegen aan events. Je kunt ook geluiden in Game Maker definiëren.
Als een speler van een spel een toets van het toetsenbord indrukt is er sprake van een
“keyboard event”, waarna een object de juiste handeling kan gaan verrichten,
bijvoorbeeld bewegen in een bepaalde richting. Ik hoop dat het idee een beetje duidelijk
is. Voor elk object dat je ontwerpt kun je actions aangeven voor verschillende events. Dit
is de manier om het gedrag van een object te definiëren.

Als je eenmaal je objecten het gedefinieerd wordt het tijd om de room waarin die
objecten zich gaan bevinden te ontwerpen. Die rooms kunnen gebruikt worden voor de
verschillende levels van het spel of om verschillende plaatsen aan te geven. Er bestaan
actions waardoor je van de ene room in de andere kunt komen.
Rooms hebben op de eerste plaats een background (achtergrond). Dit kan eenvoudig
een kleur zijn of een afbeelding. Zulke achtergrondafbeeldingen kun je met Game Maker
ontwerpen of je kunt ze importeren in Game Maker als bestaand bestand. (De
achtergrond kan een hoop dingen doen maar voorlopig beschouwen we het maar als
iets dat de room er mooi laat uitzien.) Daarna kun je de objecten in de room plaatsen. Je

9
kunt meerdere instanties van een zelfde object in de room plaatsen. Zo hoef je maar één
muurobject te definiëren terwijl je het op vele plaatsen in de room kunt gebruiken.
Bovendien kun je ook meerdere instanties van hetzelfde monsterobject in je spel
hebben, zolang ze maar hetzelfde gedrag hebben.

Nu ben je zover om het spel uit te voeren. De eerste room verschijnt in beeld met de
objecten daarin die acties uitvoeren die ze bij hun creation event hebben meegekregen.
Ze beginnen op elkaar te reageren dankzij de actions in de collision events maar ze
kunnen ook reageren op de events van de speler die worden ingegeven met de muis of
het toetsenbord.

Samenvattend kunnen we zeggen dat de volgende zaken een belangrijke rol spelen:
 Objecten: dit zijn de echte entiteiten in een spel.
 Rooms: de plaatsen (levels) waarin de objecten leven.
 Sprites: (animated) images die gebruikt worden om de objecten weer te geven.
 Geluiden: deze kunnen in spellen zowel worden gebruikt als achtergrond als ook
voor effecten.
 Achtergronden: de afbeeldingen die gebruikt worden als achtergrond in de
rooms.

Er bestaat echter nog een andere bron: scripts. Dit zijn kleine stukjes programmacode
die kunnen worden gebruikt om de mogelijkheden van Game Maker uit te breiden.
Scripts zullen in de latere hoofdstukken (voor gevorderden) behandeld worden.

10
Hoofdstuk 4 Een spelvoorbeeld nader bekeken.
Het is goed om allereerst eens te kijken hoe een erg eenvoudig spel gemaakt kan
worden. Allereerst moeten we omschrijven welk spel we gaan maken. (dit moet je altijd
als eerste doen; dat scheelt je later een hoop tijd.) Het spel dat we gaan maken is erg
eenvoudig: een bal botst tegen muren die in een rechthoek zijn geplaatst. Het is de
bedoeling dat je de bewegende bal met de linker muiskop aanklikt. Elke keer als dat
gelukt is wordt er een geluid geproduceerd, bijvoorbeeld van een geweerschot, en wordt
de score opgehoogd met 1.

Zoals uit de beschrijving is af te leiden zijn er 2 objecten nodig: de bal en de muur.

Bovendien hebben we ook twee verschillende sprites nodig: een voor het muurobject en
een voor het computerspel. Tot slot willen we een geluid horen als we erin geslaagd zijn
de bal met de muis aan te klikken. We zullen slechts 1 room gebruiken waarin het spel
zich afspeelt.

Laten we allereerst de sprites maken:

1. Selecteer uit het menu Add de optie Add Sprite. (je kunt ook het geschikte icoon
gebruiken op de werkbalk) Er verschijnt een venster. Vul in het veld Name “wall”
in.
2. Kies vervolgens de Load Sprite knop en kies een geschikte afbeelding (die kun
je onder andere vinden in de map “maze”). Dat is alles. Je kunt daarna het
venster sluiten.
3. Op dezelfde manier als boven beschreven kun je een “ball”-sprite maken.
4. Vervolgens voegen we een geluid toe. Selecteer uit het menu Add de optie Add
sound. Een ander venster verschijnt nu in beeld. Geef het geluid dat je kiest een
naam en kies daarna Load Sound. Kies een bijpassend geluid, om te
controleren of het inderdaad geschikt is kun je op de “play”-knop drukken. Als je
het geschikte geluid gevonden hebt kun je het venster sluiten.
5. Nu moeten we de 2 objecten gaan maken.
a. Allereerst het object “wall”. We kiezen weer van het Add-menu de optie
Add Object. Ook nu verschijnt er weer een venster maar dat zit ietwat
ingewikkelder in elkaar. Aan de linkerkant kun je enige algemene
informatie over het object vinden.
b. Geef het object een geschikte naam en kies uit het “drop down-menu” de
juiste “wall”-sprite. Aangezien een muur onbeweeglijk is, moet je een
vinkje zetten in de box Solid.
c. Op een zelfde manier als onder a maken we een tweede object en
noemen dat “ball”, kies daarbij de juiste sprite en maak de “ball” niet solid.
Want we gaan aan de bal enig gedrag toekennen. In het middelste veld
zie je de “events”. Kies daarvan de “creation event”. Helemaal aan de
rechterkant van het venster zie je alle mogelijke acties, in groepen
ondergebracht. Van de move-groep kies je de actie met de 8 rode pijlen
en sleept die naar het midden in de lijst. Hierdoor kan het object in een
bepaalde richting gaan bewegen. De “speed” kun je op 8 laten staan.
Meteen als je de actie in de lijst hebt gesleept verschijnt er een nieuw
venster waarin je de richtingen van de beweging van het object kunt
aangeven. Kies alle 8 de pijlen waarmee je wilt aangeven dat het object
alle kanten op kan gaan (random) De speed kun je op 8 laten staan. Sluit

11
 daarna het venster. Nu kan de bal gaan bewegen in een onbepaalde
richting zo gauw hij wordt gecreëerd.
d. Vervolgens moeten we gaan aangeven wat er gebeurt als een bal tegen
de muur botst. Zoek de “collision event”-knop (met de 2 kleine rode pijlen
die elkaar raken, de vijfde van boven) en selecteer vervolgens in het
drop-down-menu het “wall”-object. Voor deze actie maken we gebruik van
de “bounce”-actie (om te controleren wat elke actie doet, kun je de muis
erboven houden en dan verschijnt er een tekstveld met de actie erin)
e. Tenslotte moeten we nog definiëren wat er gebeurt als de gebruiker de
linker muisknop indrukt op de bal. Zoek de juiste event en selecteer de
linker muisknop van het pop-up menu. Voor deze event hebben we een
paar acties nodig: één om het geluid te laten afspelen (kan gevonden
worden in de groep van Misc.-actions. Kies het juiste geluid. Daarna een
om de score bij te houden (in dezelfde groep). Vul de waarde 1 in en
plaats tevens een vinkje in de box Relative (Dit betekent dat er 1 bij de
huidige score wordt opgeteld.). Daarna nog twee om de bal op een
nieuwe plaats te laten beginnen en in een nieuwe (random) richting te
laten verplaatsen (op dezelfde manier als bij de creation event) Als je bij
het invullen van de gegevens ergens een fout maakt kun je deze weer
herstellen door op een actie te dubbelklikken en de waarden te wijzigen.

6. Onze objecten zijn nu klaar. Wat nog overblijft is het maken van een ruimte.
Selecteer uit het Add-menu Add a new room. Aan de rechterkant zie je een
lege ruimte. Aan de linkerkant zie je enige mogelijkheden waarmee je die room
kunt wijzigen, zoals hoogte en breedte van de ruimte. Links onder staat een pop-
up menu waaruit je objecten kunt kiezen die je aan de room kunt toevoegen op
een door jou te kiezen plaats. Je kunt met een muisklik objecten overal plaatsen.
Met de rechter muisknop kun je de objecten weer verwijderen. Plaats nu een
muur in de room en vervolgens 1 of 2 ballen erin. Klaar is Kees.

7. Nu is het tijd om ons spel te testen. Druk op de Run-knop en wacht af wat er

gebeurt. Als je geen fouten hebt gemaakt beginnen de ballen rond te bewegen.
Probeer dan de ballen met de muis aan te klikken en kijk dan eens wat er
gebeurt. Het spel is altijd te stoppen door op ESC te drukken. Als iets niet goed
is uitgevoerd heb je de mogelijkheid veranderingen aan te brengen.

8. Gefeliciteerd!! Je hebt nu je eerste spelletje in elkaar gezet. Maar ik denk dat het
nu tijd is om iets meer over Game Maker te weten te komen.

12
Hoofdstuk 5 De algemene gebruikersinterface.
Als je het programma Game Maker start verschijnt het volgende venster op het scherm:

Aan de linkerzijde zie je verschillende bronnen: sprites, sounds, backgrounds, scripts,

objects, rooms en nog twee: game information en game options. Bovenaan zijn de
bekende menubalk en werkbalk te zien. In dit hoofdstuk zal ik kort de verschillende
menu-items, knoppen enz. beschrijven. In de hoofdstukken verderop zal ik een aantal
van die zaken gedetailleerd beschrijven. Merk op dat vele dingen op verschillende
manieren kunnen worden bereikt: door een commando uit het menu, door op een knop
te drukken of door met de rechtermuisknop op een bron te klikken.

5.1 File menu

In het file menu kun je enkele van de gebruikelijke commando’s vinden zoals het laden
en opslaan van files plus een paar speciale:
 New. Kies dit commando om een nieuw spel te gaan ontwerpen. Als het huidige
spel is veranderd, krijg je de vraag of die veranderingen moeten worden
opgeslagen. Er is ook een knop op de werkbalk voor de optie new.
 Open. opent een bestaand spel. Merk op dat Game Maker een onderscheid
maakt tussen ontwerpfiles met de extensie .gmd en run-only versies die de
extensie .gmr hebben. Zoals je waarschijnlijk al gedacht zou hebben: de run-only
versies kunnen alleen maar gespeeld worden en niet bewerkt. Op de werkbalk is
ook een knop voor de optie open te vinden. Je kunt ook een spel openen door
een file in het Game Maker venster te slepen.
 Save. slaat een spel op onder zijn huidige naam. Als er van te voren geen naam
was toegekend aan het spel vraagt Game Maker jou om een naam te geven. Dit

13
 commando is alleen maar te gebruiken als er wijzigingen in het spel zijn
aangebracht. Ook voor de optie save vind je een knop op de werkbalk.
 Save As. slaat het spel op onder een andere naam. Je wordt gevraagd een
nieuwe naam aan het spel te geven.
 Create stand-alone. Gebruik dit commando om een stand-alone versie van je
spel te maken dat je aan andere mensen kunt geven. In Hoofdstuk 22 vind je
meer informatie over het distribueren van spellen.
 Import scripts. Dit commando kan worden gebruikt om bruikbare scriptfiles in
Game Maker te laden. Meer hierover in Hoofdstuk 18.
 Export scripts. Dit commando kun je gebruiken om je scripts op te slaan zodat
ze ook door anderen kunnen worden gebruikt.
 Preferences. Hier kun je een aantal voorkeursinstellingen van Game Maker
instellen. Elke keer als je Game Maker opstart zullen deze instelling van kracht
zijn. De volgende instellingen kunnen worden gemaakt:
o Show recently edited games in the file menu. Na controle zullen de
laatste 4 bewerkte spellen in het filemenu worden getoond.
o Use compression when saving games. Na controle zullen de
afbeeldingen in de spellen worden gecomprimeerd. Hierdoor wordt de
spelgrootte aanzienlijk gereduceerd, maar het laden en opslaan van het
spel zal daardoor iets langer duren.
o Keep backup copies of files. Deze instelling zorgt ervoor dat er een
kopie gemaakt wordt van het spel. De file krijgt dan de extensie .bak. Als
je extensie verandert in .gmd kun je het spel weer gewoon gebruiken.
o Hide the designer and wait while the game is running. Deze optie
zorgt ervoor dat als je het spel runt het ontwerpscherm verdwijnt en weer
tevoorschijn komt als je het spel hebt beëindigd.
o Run games in secure mode. Deze instelling zorgt ervoor dat geen enkel
spel dat met Game Maker is gemaakt en dat op jouw PC draait andere
executable files zal openen of files zal veranderen of verwijderen die niet
tot het spel behoren. (dit is bedoeld als bescherming tegen Trojaanse
paarden) Het kan betekenen dat sommige spellen niet goed draaien.
o In object properties, show hints for actions. Deze optie zorgt ervoor
dat als je met de muis over een van de actions in het veld van de
eigenschappen van objecten gaat er een venster verschijnt met de
beschrijving van die action.
o Scripts and code. Zie Hoofdstuk 18 voor meer informatie over deze
instelling.
o Image editor. Default Game Maker gebruikt een built-in editor voor
plaatjes. Als je zelf een beter editor-programma hebt kun je op deze
plaats aangeven dat je gebruik wil maken van dat editor-programma.
 Recent files. Behalve als deze optie in de voorkeursinstellingen is uitgezet, zul
je de laatste vier files te zien krijgen die je hebt geopend. Met een simpele
muisklik zijn deze weer te openen.
 Exit. Dat spreekt voor zich. Klik hierop om Game Maker te beëindigen. Als je het
openstaande spel hebt gewijzigd, zal Game Maker vragen of de wijzigingen
moeten worden opgeslagen.

14
5.2 Edit menu
Het edit menu bevat een aantal commando’s dat betrekking heeft op de op dat
moment geselecteerde voorwerp (object, sprite, geluid, enz.) of groep voorwerpen.
Afhankelijk van het type voorwerp kan het zijn dat een of meerdere commando’s niet
beschikbaar zijn.
 Insert resource. Voeg een nieuwe instantie toe van het huidig gekozen type
voorwerp vóór het huidige exemplaar. Als je een groep voorwerpen hebt
geselecteerd zal het voorwerp in de groep worden toegevoegd. Een venster
zal op het beeldscherm verschijnen waarin je de eigenschappen van het
voorwerp kunt wijzigen. In de volgende hoofdstukken zal hierover in detail
worden ingegaan.
 Duplicate. Hiermee kun je een kopie maken van het huidige voorwerp en
voegt het vervolgens toe. Er verschijnt een venster waarin je het voorwerp
kunt veranderen.
 Insert group. Voorwerpen kunnen samen in een groep geplaatst worden.
Dit is erg nuttig als je grote spellen gaat maken. Bijvoorbeeld: je kunt alle
geluiden bij elkaar nemen die bij een bepaald object horen, of je kunt alle
objecten die samen in een level thuishoren in een groep bij elkaar plaatsen.
Dit commando maakt een nieuwe groep in het huidig geselecteerde type
voorwerp.
 Delete. Verwijdert het op dat moment geselecteerde voorwerp (of groep
voorwerpen). Wees daar voorzichtig mee. Er is geen optie om dit ongedaan
te kunnen maken. Daarvoor word je echt gewaarschuwd.
 Rename. Geeft het voorwerp een andere naam. Dat kun je ook realiseren in
het eigenschappenvenster van het voorwerp.
 Properties. Met dit commando kun je het eigenschappenvenster van een
voorwerp oproepen om de eigenschappen te bewerken. Merk op dat alle
eigenschappenvensters binnen het hoofdscherm verschijnen. Je kunt vele
voorwerpen tegelijkertijd bewerken. Je kunt het eigenschappenvenster ook
oproepen door op het voorwerp dubbel te klikken.
 Show Object Information. Als je dit commando gebruikt krijg je een
overzicht van alle objecten in het spel.
Merk op dat al deze commando’s ook op een andere manier aangeroepen kunnen
worden. Door met de rechtermuis op een voorwerp of voorwerpengroep te klikken
verschijnt er een pop-up menu.

5.3 Add menu

In dit menu kun je nieuwe voorwerpen van elk type object toevoegen. Merk op dat er ook
voor elk type een knop op de werkbalk voorkomt en dat er voor elk type een
sneltoetscombinatie bestaat.

5.4 Window menu

In dit menu vind je enkele gebruikelijke commando’s om windowmanagement toe te
passen in het hoofdvenster. Je kunt daar kiezen voor:
 Cascade. Zet alle vensters in een cascade onder elkaar, zoadat ze slechts
gedeeltelijk zichtbaar zijn.
 Arrange Icons. Groepeert alle eigenschapvensters met een icoon (met name
handig als je het hoofdvenster van grootte gaat veranderen).

15
  Close All. Deze optie sluit alle eigenschappenvensters, maar eerst wordt er nog
gevraagd om de wijzigingen op te slaan of niet.

5.5 Help menu

In dit menu vind je enige commando’s terug die je kunnen helpen, zoals:
 Contents. Met dit commando roep je de online versie van deze handleiding op.
 How to use help. Als je niet weet hoe je de helpfunctie moet gebruiken, kun je
hier hulp krijgen.
 Web site. Deze optie verbind je met de Game Maker website, waar de meest
actuele informatie over de meest recente versie van Game Maker kunt vinden
samen met een verzameling spellen en documentatie. Ik adviseer je om
minstens eenmaal per maand op de site te kijken voor nieuwe informatie.
 About Game Maker. Dit geeft enige korte informatie over de gebruikte versie
van Game Maker.

5.6 De resource explorer (bronnen/voorwerpen verkenner)

Aan de linkerkant van het hoofdvenster vind je de resource explorer. Je treft hier een in
boomvorm een lijst met alle voorwerpen (objecten, sprites, achtergronden etc.) aan die
in je spel voorkomen. Hij werkt hetzelfde als de Windows verkenner, waarvan ik
aanneem dat je daar aardig mee uit de voeten kunt. Als een bepaald item aan de
linkerkant voorzien is van een +(plus-) teken, houdt dat in dat dit item meerdere items in
zich heeft, net als een map, waarin nog meerdere mappen zitten. Als je erop klikt,
komen de onderliggende voorwerpen tevoorschijn en verandert het plusteken in een
minteken. Als je daarna op het minteken klikt, wordt de map weer gesloten en verandert
het minteken weer in een plusteken. Je kunt de namen van voorwerpen veranderen,
alleen de namen op het hoogste niveau zijn standaard en daardoor onveranderbaar. Je
moet dan het voorwerp selecteren (met een enkele klik van de muis) en daarna op de
naam klikken. Om de eigenschappen van een voorwerp aan te passen moet je op het
voorwerp dubbelklikken. Met de rechtermuisknop kun je dezelfde commando’s bereiken
als met het Edit menu. Je kunt in de resource explorer de volgorde van de voorwerpen
wijzigen door met de rechtermuisknop een voorwerp te selecteren, de muisknop
ingedrukt te houden en vervolgens naar de gewenste plaats te slepen en daarna de
muisknop los te laten. Dit kan ook met hele groepen. Het is overigens wel zo dat je
voorwerpen alleen maar in de juiste groep kunt verplaatsen. Het is dus niet mogelijk
geluiden te verslepen naar de spritesgroep of omgekeerd.

16
Hoofdstuk 6 Het definiëren van sprites
‘Sprites’ zijn de visuele representaties van alle objecten in het spel.
Een sprite is één plaatje op zich, getekend met elk willekeurig programma, of een set
van plaatjes, die werken als een animatie.

Wanneer je begint met het ontwerp van een spel, ga je sprites verzamelen als objecten
in jou spel.
Een sprite collectie, zowel statisch als geanimeerd, wordt door Gamemaker bijgeleverd.
Andere sprites kun je vinden op het web in de vorm van ‘animated gifs’.

Om een sprite toe te voegen kies je Add Sprite in het Add menu, of maak gebruik van
de corresponderende knop in de werkbalk.

Bovenaan kun je de naam van de sprite aangeven. Alle sprites (en alle andere bronnen)
hebben een naam. Je kunt het beste kiezen voor een duidelijk omschrijvende naam.
Zorg ervoor dat alle bronnen een verschillende naam hebben.
Gebruik alleen letters en getallen en het underscore symbool in de naam van een sprite
(of een andere bron) en laat de naam beginnen met een letter. Gebruik geen spaties!
Dit is vooral belangrijk wanneer je begint met code schrijven.
Er zijn twee tabs, genaamd Standard en Advanced.
Op dit moment gaan we werken met de Standard en laten we de Advanced nog even
buiten beschouwing tot Hoofdstuk 13.

17
Hoofdstuk 7 Bewegingen en muziek
De meeste spellen hebben bepaalde geluidseffecten en bepaalde achtergrondmuziek.
Sommige nuttige geluidseffecten worden geleverd bij Gamemaker. Veel meer
geluidseffecten zijn te vinden op het web.

Om bepaalde geluidsbronnen toe te voegen aan je spel, gebruik je het item Add Sound
in het Add menu of je kunt gebruik maken van de corresponderende button in de
menubalk.
Het volgende scherm verschijnt:

Bovenin kun je de naam veranderen van de geluidsbron. Opnieuw zijn er twee tabs
namelijk: Standard en Advanced.
Opnieuw bespreken we hier alleen de standaardoptie.
Over de Advanced tab wordt gesproken in Hoofdstuk 14.

Om een geluid te laden, klik je op de knop met Load Sound.

Een dialoogscherm verschijnt, waarin je het geluidsbestand kunt selecteren.
Er zijn twee soorten geluidsbestanden, ‘wave files’ en ‘midi files’.
(voor meer informatie over mp3 files; zie Hoofdstuk 14).

‘Wave files’ worden gebruikt voor korte geluidseffecten. Deze files gebruiken veel
geheugenruimte, maar spelen onmiddellijk. Gebruik deze files voor al je geluidseffecten
in je spel. ‘Midi files’ beschrijven muziek op een andere manier. Zij gebruiken veel
minder geheugen, maar blijven beperkt tot instrumentale achtergrondmuziek. Eén ‘midi
file’ kun je laten spelen en niet meerdere tegelijkertijd.

Wanneer je een muziek file laadt, worden zijn lengte en aard vertoond. Je kunt het
beluisteren terwijl je gebruik maakt van de playbutton.

18
Hoofdstuk 8 Achtergronden
Het derde type basisbronnen aanwezig in Gamemaker zijn de achtergronden. Het zijn
meestal grote afbeeldingen die als achtergrond (of voorgrond) worden gebruikt voor de
ruimtes waarin het spel zich afspeelt. Vaak worden achtergrondafbeeldingen zo
gemaakt dat zij een gebied bedekken zonder visuele problemen (oneffenheden). Je kunt
op deze manier de achtergrond vullen met een bepaald patroon. Een aantal van deze
bedekkende achtergronden zijn in Gamemaker bijgeleverd. Veel meer kunnen gevonden
worden op het web.

Om een achtergrond bij te voegen, gebruik je het item Add Background in het Add
menu of maak je gebruik van de corresponderende knop in de taakbalk. Het volgende
scherm verschijnt:

Opnieuw kun je een naam toevoegen en opnieuw zijn er Standard en Advanced tabs.
Voor meer informatie over de advanced opties; zie Error: Reference source not found.
Klik op de knop Load Background om een achtergrondplaatje te laden.
Game Maker ondersteunt vele typen afbeeldingbestanden.
Achtergrond afbeeldingen kunnen niet geanimeerd worden!
De Checkbox Transparent geeft aan of de achtergrond gedeeltelijk transparant is of
niet. De meeste achtergronden zijn niet transparant waardoor de default waarde ‘not‘ is.
De transparantiekleur wordt bepaald door de kleur van de pixel in de linker
benedenhoek van de afbeelding.

Je kunt de achtergrond veranderen of een nieuwe creëren door gebruik te maken van de
knop Edit Background.
Voor meer informatie kun je terecht in Error: Reference source not found.

19
Hoofdstuk 9 Het definiëren van objecten
We kunnen nu al leuke plaatjes en geluiden hebben toegevoegd aan ons spel, maar ze
doen niets.
We komen nu aan de meest belangrijke bron van Game Maker: de objecten.
Objecten zijn entiteiten in het spel die iets doen. Meestal hebben zij een grafische
representatie als sprite, zodat je ze kunt zien. Zij vertonen gedrag in de zin dat zij
kunnen reageren op bepaalde gebeurtenissen. Alle dingen die je kunt zien in het spel
(behalve de achtergrond) zijn objecten (of preciezer; zij zijn instanties van objecten). De
figuren als monsters, ballen, muren enz. zijn allemaal objecten. Er kunnen ook objecten
aanwezig zijn, die je niet ziet, maar die wel aspecten van het spel bepalen.
Het is belangrijk dat je het verschil tussen ‘sprites’ en ‘objecten’ realiseert. ‘Sprites zijn
alleen maar geanimeerde plaatjes die geen bepaald gedrag vertonen. Objecten hebben
meestal een ‘sprite’ die hen representeert, maar het zijn de objecten die het gedrag
vertonen. Zonder ‘objecten’ is er geen spel!!!!!

Het is ook belangrijk dat je het verschil tussen ‘objecten’ en ‘instanties’ begrijpt.
Een object beschrijft een bepaalde entiteit; bijv. een monster. Er kunnen meerdere
instanties van dit object in het spel bestaan. Wanneer we praten over een instantie
bedoelen we één bepaalde instantie van het object. Wanneer we praten over het object,
bedoelen we alle instanties van dit object.

Om een object toe te voegen aan het spel, kies je Add Object in het Add menu. Het
volgende scherm verschijnt:

Het is ingewikkeld. In het linker deel van het scherm zie je algemene informatie over het
object. In het midden deel zijn verschillende mogelijke gebeurtenissen zichtbaar, die het
object kunnen overkomen. In het volgende hoofdstuk wordt hier nader op ingegaan. Aan
de rechterkant van het scherm zie je verschillende acties die het object kan
ondernemen. Deze worden beschreven in Hoofdstuk 11.

20
Zoals altijd geef je het object een naam. Vervolgens wijs je een sprite toe aan het object.
Hiertoe klik je met de linker muis knop op de sprite box of de menuknop ernaast.
Een menu verschijnt met de mogelijke sprites. Selecteer degene die je wilt gebruiken
voor het object. Hieronder vind je twee checkboxes. De box die Solid heet, geeft aan
dat het om solide object gaat; bijv. een muur. Botsingen met solide objecten worden
anders afgehandeld dan botsingen met niet-solide objecten. In het volgende hoofdstuk
vind je meer informatie hierover.
Visible geeft aan of instanties van objecten zichtbaar zijn. De meeste objecten zijn
zichtbaar, maar soms is het handig om onzichtbare objecten te hebben. Bijvoorbeeld
wanneer het richtingspunten zijn voor een bewegend monster. Onzichtbare objecten
reageren op gebeurtenissen en andere instanties die met hen in botsing komen.

De knop Show Information geeft een overzicht van alle informatie die hoort bij het
object, welke ook geprint kan worden. Dit is vooral belangrijk wanneer je het overzicht
verliest over alle acties en gebeurtenissen binnen het spel.

21
Hoofdstuk 10 Gebeurtenissen (Events)
Game Maker gebruikt een gebeurtenis gedreven benadering (event driven approach).
Dat betekent dat instanties van objecten gebeurtenissen ontvangen (een soort
boodschappen dat er iets is gebeurd). Ze kunnen hierop reageren door bepaalde acties
uit te voeren. Voor ieder object moet je vastleggen op welke gebeurtenissen het moet
reageren en welke acties het object dan moet ondernemen. Dit lijkt misschien
gecompliceerd, maar is eigenlijk vrij gemakkelijk.
Voor de meeste gebeurtenissen hoeft het object niets te doen. Voor de gebeurtenissen
waar wel op gereageerd moet worden, kun je een ‘drag and drop’ benadering kiezen om
de acties vorm te geven.

In het volgende deel moet je letten op figuur ‘Object properties’ op pag. 21 en het figuur
hieronder.
In het midden van het objecteigenschappen scherm zien je een aantal buttons genaamd
Create, Destroy enz.
Het zijn verschillende gebeurtenissen. Verderop in het hoofdstuk vind je een complete
lijst met beschrijvingen. Eén van deze buttons is donkergrijs. Dit is de gebeurtenis die
we voortdurend wijzigen. Aan de rechterkant worden deze acties gerepresenteerd door
kleine icoontjes. Zij worden gegroepeerd in een aantal door tabbladen aangegeven
pagina’s.
In het volgende hoofdstuk wordt beschreven welke acties mogelijk zijn en wat zij
inhouden.
Tussen de gebeurtenissen en acties is een lijst. Deze lijst bevat de acties voor een
bepaalde gebeurtenis. Om acties toe te voegen aan de lijst, trek je hen met de muis van
de rechterkant naar de lijst. Zij worden onder elkaar geplaatst, met een korte
beschrijving erbij. Voor iedere actie word je gevraagd een aantal parameters mee te
geven. Deze worden ook beschreven in het volgende hoofdstuk. Dus na een paar acties
wordt de situatie bijv. als volgt:

22
De geselecteerde(donkergrijze) event Create is vet geworden. Dit geeft aan dat het
actie bevat. Iedere event die acties bevat, heeft een vetgedrukte naam. Je kunt nu
beginnen met acties aan events mee te geven.
Klik op een bepaalde event met de linker muisknop om het te selecteren (de button
wordt donkergrijs) en trek een actie naar de lijst.

Je kunt de volgorde waarin de acties in de lijst staan veranderen, door gebruik te maken
van drag-and-drop. Wanneer je de <Ctrl> knop vasthoudt terwijl je sleept, maak je een
kopie van de actie.
Je kunt drag-and-drop gebruiken tussen actielijsten van de verschillende objecten.
Wanneer je klikt op een actie met de rechter muisknop, verschijnt een menu waarin je
een actie kunt verwijderen (dit kan ook door de <del> knop te gebruiken) maar ook kunt
knippen en plakken. In het volgende hoofdstuk staat meer informatie over acties.
Er bestaat een grote collectie verschillende events. Zoals je kunt zien in het object
properties scherm, hebben sommige menunamen een menu symbool naast zich. Dit
betekent dat er een collectie van events is. Wanneer je klikt op het menu, of rechts klikt
op de eventnaam, verschijnt een menu waarin je een event kunt kiezen die je wilt
veranderen. Hier volgt een beschrijving van de verschillende events. (normaal gebruik je
maar een paar van deze).

Create event
Deze event treedt op wanneer een instantie van een object wordt gecreëerd. Het wordt
meestal gebruikt om een instantie in beweging te zetten en/of bepaalde variabelen in te
stellen voor deze instantie.

Destroy event
Deze event treedt op wanneer de instantie wordt vernietigd. Eigenlijk treedt dit event op
vlak voordat de instantie wordt vernietigd, zodat de instantie nog bestaat wanneer de
event wordt uitgevoerd.
Meestal wordt deze event niet gebruikt, behalve wanneer het de bedoeling is om de
score te wijzigen, of om een ander object te creëren.

Alarm events
Iedere instantie heeft 8 alarm klokken. Je kunt deze alarmklokken inschakelen door
bepaalde acties te gebruiken(zie het volgende hoofdstuk). De alarmklok tikt dan af tot 0
en op dat moment wordt de alarm event gegenereerd. Om de acties voor een bepaalde
alarm klok aan te geven, moet het eerst geselecteerd worden in het menu.
Alarm klokken zijn zeer nuttig. Je kunt hen gebruiken om bepaalde dingen te laten
gebeuren in de tijd. Bijvoorbeeld om de bewegingsrichting van een monster na iedere 20
stappen te wijzigen. (In dit geval moet één actie in de event de klok opnieuw instellen).

Step event
De step event treedt op bij iedere stap in het spel. Hier kun je acties plaatsen die continu
uitgevoerd moeten worden. Bijvoorbeeld; wanneer een object een ander object moet
volgen, kun je hier de bewegingsrichting aanpassen zodat het tweede object gevolgd
wordt.
Met deze event moet je voorzichtig zijn. Geef niet veel van deze gecompliceerde acties
in de step event van objecten mee, wanneer er veel instanties van dit object zijn. Dit

23
vertraagt het spel. Eigenlijk zijn er drie verschillende step events. Meestal heb je alleen
de default nodig.
Wanneer je het menu gebruikt, kun je de begin en eind step event laten plaatsvinden.
De normale step event wordt uitgevoerd vlak voordat de instanties in hun nieuwe
posities worden geplaatst. De eind step event wordt uitgevoerd aan het einde van de
step, vlak voor het tekenen. Dit wordt gebuikt om de sprite te laten veranderen
afhankelijk van de richting.

Collision event
Wanneer twee instanties botsen (sprites overlappen) treedt een collision event op.
Eigenlijk treden twee collision events op, voor iedere instantie één.
De instantie kan op deze event reageren. Selecteer in het menu het object waarmee je
een collision event wilt definiëren. Daarna worden in het collision event de acties
geplaatst.

Er bestaat een verschil in wat er gebeurt, wanneer een instantie botst met een solide
object of dat een instantie botst met een niet-solide object.
Wanneer er geen acties in de collision event zijn opgenomen, gebeurt er niets. De
huidige instantie blijft gewoon bewegen; zelfs wanneer het andere object een solide
object is.

Wanneer de collision event acties bevat, gebeurt het volgende:

Botsing met een solide object: de instantie wordt teruggeplaatst op zijn voorafgaande
plaats ( dus vóór de botsing plaatsvindt). De event wordt uitgevoerd. Uiteindelijk wordt
de instantie naar zijn nieuwe positie verplaatst. Dus wanneer de event de
bewegingsrichting omkeert, botst de instantie op de muur zonder te stoppen.

Wanneer het andere object een niet-solide object is, wordt de instantie niet teruggezet.
De event wordt gewoon uitgevoerd, met de instantie op zijn huidige positie. Er wordt
geen tweede check gedaan op botsingen. Omdat het object niet solide is, kunnen we er
gewoon over heen bewegen. De event geeft aan dat dit gebeurt.

Er zijn veel mogelijkheden voor de collision event. Instanties kunnen het gebruiken om
tegen muren te botsen. Je kunt het gebruiken om objecten te vernietigen wanneer zij
geraakt worden door bijv. een bullet.

Keyboard events
Wanneer de speler een toets indrukt, vindt een keyboard event plaats voor alle
instanties van alle objecten. Er is een verschillende event voor iedere toets. In het menu
kun je de toets kiezen, waarvoor je de keyboard event wilt definiëren en daar acties naar
toe brengen. Slechts een paar objecten hebben events nodig voor slechts een paar
toetsen.
Er zijn twee verschillende manieren waarin je keyboard events kunt ontvangen. Zij zijn
continue, d.w.z. zolang als de toets wordt ingedrukt vindt een keyboard event plaats in
iedere stap. Wanneer zij niet continue zijn vindt er een slechts één keyboard event
plaats, wanneer de toets wordt ingedrukt en opnieuw wanneer de toets weer wordt
ingedrukt.
Er zijn twee speciale keyboard events.
Ten eerste: <No key>. Deze event treedt op in iedere stap wanneer geen toets wordt
ingedrukt.

24
De tweede heet <Any key> en treedt op wanneer elke willekeurig toets wordt ingedrukt.
Wanneer de speler meerdere toetsen indrukt, treden voor alle ingedrukte toetsen events
op.
Let op: wanneer toetsen van het numerieke toetsenbord worden ingedrukt vinden alleen
de corresponderende events plaats, wanneer ook <NumLock> is ingedrukt.

Mouse events
Een muis event vindt plaats, wanneer de muiscursor ligt binnen het sprite gebied die de
instantie representeert. Afhankelijk van welke muisknop wordt ingedrukt, krijg je de
linkerknopevent, de rechterknopevent, de geenknopevent of de middelsteknopevent.
Deze events vinden alleen plaats, zolang de muis boven de instantie is. Wanneer de
speler op een muisknop drukt wanneer er geen instantie is, treedt geen event op. Soms
is het belangrijk om op iedere muisklik te reageren. Dit kan worden gerealiseerd door
een sprite te ontwerpen, met de grootte van de room.
Creëer een object met deze sprite die de hele room bedekt en maak dit object
onzichtbaar. Plaats het in iedere kamer en het zal events genereren bij iedere muisklik
die plaatsvindt.

Andere events
Er zijn een aantal andere events die bruikbaar kunnen zijn in bepaalde spellen.
Zij staan hieronder genoemd:
 Outside: Deze event vindt plaats wanneer een instantie totaal buiten de kamer
ligt. Dit is een goed moment om het te vernietigen.
 Boundary: Deze event vindt plaats wanneer de instantie de grens van de kamer
snijdt.
 Game start: Deze gebeurtenis treedt op bij alle instanties in de eerste kamer,
wanneer het spel start. Het treedt op voor de ‘room start’ event (zie hieronder) en
vóór de creation events van de instanties in de kamer. Deze event wordt
gedefinieerd in slecht één ‘controller’ object en wordt gebruikt om
achtergrondmuziek te starten of om sommige variabelen te initialiseren of data te
laden.
 Game end: Deze event vindt plaats voor alle instanties wanneer het spel eindigt.
Opnieuw wordt dit event gedefinieerd door slechts één object. Het kan bijv.
worden gebruikt om data in een bestand op te slaan.
 Room start: Deze event treedt op bij alle instanties die in de room aanwezig zijn,
op het moment dat de room start. Het treedt op vóór de creatie events.
 Room end: Deze event treedt op bij alle bestaande instanties op het moment dat
de room wordt beëindigd.
 No more lives: Game Maker heeft een built-in lives systeem. Er bestaat geen
actie om het aantal levenden in te stellen en te veranderen. Wanneer het aantal
levenden kleiner of gelijk aan 0 wordt, treedt deze event op. Het wordt gebruikt
om het spel te beëindigen of opnieuw op te starten.
 End of animation: Zoals boven al aangegeven, bestaat een animatie uit een
aantal plaatjes die achtereenvolgend zichtbaar worden. Nadat het laatste plaatje
zichtbaar is geweest, begint de eerste weer. De event treedt precies op dat
moment op. Dit kan worden gebruikt om een animatie te veranderen of om een
instantie te vernietigen.
 User defined: Er zijn acht van deze events. Normaliter treden zij nooit op, tenzij
je hen zelf oproept, vanuit de code.

25
 Drawing event
Zichtbare instanties tekenen hun sprites in iedere stap van het scherm. Wanneer je
acties in de drawing event specificeert, wordt de sprite niet getekend, maar worden de
gespecificeerde acties uitgevoerd. Dit kan worden gebruikt om iets anders dan de sprite
te tekenen of veranderingen aan te brengen in de sprite parameters. Er zijn een aantal
drawing actions die speciaal bedoeld zijn voor de drawing event. De drawing event
wordt niet alleen uitgevoerd wanneer het object zichtbaar is.
Onafhankelijk van wat je hier tekent, zijn collision events gebaseerd op de sprite die is
geassocieerd met de instantie.

26
Hoofdstuk 11 Acties
In Game Maker vinden acties plaats. Acties worden geplaatst in events. Wanneer een
event optreedt, worden de acties zichtbaar. Er is een groot aantal verschillende acties
beschikbaar en het is belangrijk dat je begrijpt wat zij doen. In dit hoofdstuk wordt dat
beschreven.

Alle acties kun je vinden in de tabbladen aan de rechterzijde van het Object property
venster.
Er zijn zes sets met acties. Door op de correcte tab te klikken, vind je de set. Wanneer je
de muis boven één van de acties houdt, zie je een korte omschrijving van de functie.
Om een actie in een event te plaatsen moet je het van de tabbladen naar de actielijst
slepen. Je kunt de volgorde in de lijst veranderen op dezelfde manier. Wanneer de
<Ctrl> knop wordt vastgehouden tijdens het slepen, wordt een kopie gemaakt van de
actie. Je kunt slepen en kopiëren tussen de lijsten in verschillende object property
vensters. Gebruik de rechter muisknop om acties te verwijderen (of gebruik de <DEL>
knop) en voor kopieer en plak acties.

Wanneer je een actie instelt, verschijnt er meestal een pop-up scherm, waarin je
bepaalde parameters voor die actie kunt invullen. Twee typen parameters verschijnen in
veel acties. Bovenaan kun je aangeven naar welke instantie de actie verwijst. De default
waarde is ‘self’; de instantie waarin de actie als eerste zichtbaar is gemaakt. Meestal is
dit wat je wilt. Wanneer sprake is van een collision event, kun je ook specificeren naar
welke andere instantie betrokken bij de botsing, de actie moet verwijzen. Op die manier
kun je bijvoorbeeld andere instanties vernietigen.
Je kunt ook kiezen om de actie te laten verwijzen naar alle instanties van een object. Op
die manier kun je bijvoorbeeld alle rode ballen in blauwe ballen veranderen.
De tweede wijze waarop parameters nodig zijn is de box labeled Relative.
In deze box geef je waarden mee die relatief zijn aan de huidige waarden.
Op die manier kun je iets toevoegen aan de huidige score zonder de huidige score te
moeten veranderen in een nieuwe score. De andere parameters komen hieronder aan
bod.
Je kunt altijd parameterwaarden veranderen door te dubbelklikken op een actie.

11.1 Bewegingsacties
De eerste set van acties bestaat uit acties die met de beweging van objecten te maken
hebben.
De volgende acties bestaan:

Start moving in a direction

Gebruik deze actie om de instantie in een bepaalde richting te laten bewegen.
Je kunt de richting aangeven door gebruik te maken van de pijltjestoetsen.
Gebruik de middelste knop om een beweging te stoppen. Je moet ook de snelheid van
beweging specificeren. Deze snelheid is gegeven in ‘pixels per step’.
De default waarde is 8. Het verdient de voorkeur om geen negatieve waarden te
gebruiken. Je kunt meerdere richtingen specificeren. In dit geval wordt random een
keuze gemaakt. Op die manier kun je een monster bijv. zowel links als rechts laten
bewegen.

27
 Set direction and speed van beweging
Een tweede manier om een beweging te specificeren met de blauwe pijlen.
Hier kun je een precieze beweging specificeren. Het betreft een hoek tussen 0 en 360
graden.
0 betekent naar rechts. De richting is tegen de wijzers van de klok in. Bijvoorbeeld; 90
betekent een opwaartse beweging. Wanneer je een willekeurige richting wilt, type je
random(360).
Zoals je verderop zult zien, betekent random een random getal dat kleiner is dan de
geïndiceerde waarde. Zoals je misschien hebt gezien bestaat er een checkbox die het
label Relative draagt.
Wanneer je deze aanvinkt, wordt de nieuwe beweging toegevoegd aan de
voorafgaande. Bijv. wanneer een instantie naar boven beweegt en je voegt een beetje
beweging naar links toe, dan wordt de nieuwe beweging naar linksboven.

Set the horizontal speed

De snelheid van een instantie bestaat uit een horizontaal en verticaal deel. Met deze
actie verander je de horizontale snelheid. Een positieve horizontale snelheid betekent
een beweging naar rechts.
Een negatieve horizontale snelheid zorgt dus voor een beweging naar links. De verticale
snelheid blijft gelijk. Gebruik ‘relative’ om de snelheid te verhogen of verlaag het door het
van een negatief getal te voorzien.

Set the vertical speed

Op dezelfde manier als boven kun je de verticale snelheid veranderen.

Move towards a point

Met deze actie kun je bewegingen op een andere manier specificeren. Je stelt een
positie en een snelheid vast en de instantie begint in de richting van die positie en met
die snelheid te bewegen.
Het stopt niet bij die positie!!! Bijvoorbeeld: wanneer je een kogel in de richting van de
positie van een ruimteschip wilt laten vliegen, kun je een positie spaceship.x, spaceship.y
gebruiken. Wanneer je de Relative box aanvinkt, kun je de positie specificeren die
relatief is aan de huidige positie van de instantie. De snelheid wordt niet relatief
berekend.

Set the gravity

Met deze actie kun je graviditeit voor een bepaald object creëren Je specificeert een
richting (hoek tussen 0 en 360 graden) en een snelheid en bij iedere stap wordt de
grootte van de snelheid in een bepaalde richting, toegevoegd aan de huidige beweging
van de objectinstantie.
Meestal heb je een hele kleine snelheidsverhoging nodig ( ca. 0.01)
Je zult bij deze actie meestal een neerwaartse beweging willen hebben (270 graden).
Wanneer je de Relative box aanvinkt, kun je de neerwaartse beweging (graviditeit) en
richting vergroten. In tegenstelling tot de echte wereld, kan graviditeit in alle richtingen
optreden.

28
 Set the friction
Frictions vertragen instanties wanneer zij bewegen. Je specificeert de grootte van de
friction. Bij iedere stap wordt dit getal van de snelheid afgetrokken tot de snelheid
uiteindelijk 0 wordt. Meestal gebruik je een heel klein getal (bijv. 0.01).

Jump to a given position

Bij gebruik van deze actie kun je de instantie in een bepaalde positie brengen.
Daartoe moet je de x- en y-coördinaten specificeren en vervolgens wordt de instantie
neergezet op deze positie, vanuit zijn referentiepunt. Wanneer je Relative aanklikt, wordt
de nieuwe positie relatief berekend t.o.v. de huidige positie van de instantie.

Jump to the start position

Deze actie plaatst de instantie terug op de plaats waar het is gecreëerd

Jump to a random position

Deze actie beweegt de instantie naar een random positie in de kamer. Er worden alleen
posities gekozen, waarbij de instantie nergens een solide instantie doorsnijdt.
Je kunt deze specificeren. Wanneer je positieve waarden kiest, worden coördinaten
gekozen die veelvouden van integers zijn van de geïndiceerde waarden. Dit kan gebruikt
worden om de instantie uit te lijnen binnen de grenzen van je spel. Je kunt horizontale
en verticale waarden invoeren.

Reverse horizontal direction

Met deze actie wordt de horizontale beweging van de instantie omgedraaid. Dit gebruik
je bijv. wanneer een object tegen een verticale muur botst.

Reverse vertical direction

Met deze actie wordt de verticale beweging van de instantie omgedraaid. Dit kan bijv.
worden gebruikt wanneer het object tegen een horizontale muur botst.

Bounce against objects

Wanneer deze actie wordt geplaatst in de collision event van een bepaald object, zal het
object op een natuurlijke manier terugbotsen vanaf een muur. Wanneer je de parameter
‘precise’ op false zet, worden horizontale en verticale muren correct behandeld.
Wanneer je deze parameter op true zet, worden ook scheve en gebogen muren correct
behandeld. Echter deze gaan langzamer. Je kunt ook aangeven of je wilt laten stuiten
van solide objecten of van alle objecten. Het stuiten kan nooit volledig correct zijn, omdat
dit van vele eigenschappen afhankelijk is. In de meeste situaties is het effect echter
goed genoeg.

29
 Snap to grid
Met deze actie kun je de actie van een instantie binnen een rooster houden. Je kunt
horizontale en verticale waarden meegeven (grootte van de cellen op het rooster). Op
deze manier zorgen je ervoor dat instanties binnen het rooster blijven.

11.2 Object gerelateerde acties

De volgende groep acties gaat over het creëren, veranderen en vernietigen van
instanties van de objecten.

Create an instance of an object

Met deze actie kun je een instantie van een object creëren Je specificeert het object dat
je wilt creëren en de positie van de nieuwe instantie. Wanneer je de Relative box
aanvinkt, wordt de positie berekend relatief aan de positie van de huidige instantie. Het
creëren van instanties tijdens het spel is zeer bruikbaar. Een ruimteschip kan kogels
creëren, een bom kan een explosie creëren In veel spelletjes is een controller element
aanwezig die van tijd tot tijd monsters of andere objecten creëren. Voor het creëren van
nieuwe instanties wordt de creation event uitgevoerd.

Change the instance

Met deze actie kun je de huidige instantie in een ander object laten veranderen.
Bijvoorbeeld: je kunt een bom in een explosie laten veranderen. Alle ‘settings’ zoals
beweging of waarden van variabelen zullen hetzelfde blijven. Je kunt aangeven of de
destroy event voor het huidige object en de creation event voor het nieuwe object moet
gelden.

Destroy the instance

Met deze actie wordt de huidige instantie vernietigd.

Destroy instances at a position

Met deze actie vernietig je alle instanties die in hun box begrenzing een bepaalde positie
bevatten.
Dit kan belangrijk zijn wanneer je een bom wilt laten exploderen. Wanneer je de relative
box aanvinkt, wordt de positie relatief berekend t.o.v. de positie van de huidige instantie.

Change the sprite

Gebruik deze actie om de sprite voor de instantie te veranderen. Je indiceert een nieuwe
sprite. Je kunt ook een schubfactor aangeven. Factor 1 betekent dat de sprite niet
geschubd is. Een schubfactor moet groter zijn dan 0. Realiseer je dat een geschubde
sprite meer tijd vergt om te tekenen.
Het veranderen van sprites is een belangrijk kenmerk. Bijv. wanneer je een sprite van
figuur wilt laten veranderen, afhankelijk van de richting in welke het loopt. Dit kan
worden bereikt wanneer je verschillende sprites maakt voor iedere vier richtingen.
Binnen de keyboard events voor de pijltjestoetsen wordt de bewegingsrichting van de
sprite gespecificeerd.

30
11.3 Diverse acties

Hier volgt een grote collectie aan acties die met allerlei aspecten te maken hebben:
geluid, kamers, scores enz.

Play a sound
Met deze actie speel je een geluidsbron af die je aan het spel hebt toegevoegd. Je kunt
aangeven welke muziek je wilt laten spelen en of het eenmaal speelt (default) of dat het
steeds weer opnieuw begint.
Wanneer je een midi bestand start wordt het vorige midibestand gestopt. Tenzij anders
vermeld is in de advanced tab (zie Hoofdstuk 14) slechts één instantie van iedere
muziek kan spelen. Dus wanneer hetzelfde lied al wordt gespeeld, wordt deze gestopt
en opnieuw opgestart.

Stop a sound
Deze actie stopt het geïndiceerde geluid. Wanneer meerdere instanties van dit lied aan
het spelen zijn, worden deze allemaal gestopt.

Set an alarm clock

Met deze actie kun je één van de acht alarmklokken voor een instantie instellen. Je kunt
het aantal stappen en de alarmklok instellen. Na het ingestelde aantal stappen, ontvangt
de instantie de corresponderende alarm event. Je kunt de waarde verhogen of verlagen
door de Relative box aan te vinken. Wanneer je de alarmklok instelt op een waarde
minder dan of gelijk aan 0, wordt de event niet gegenereerd.

Display a message
Met deze actie kun je een boodschap meegeven in een dialog box. Simpelweg wordt de
boodschap ingetypt. Wanneer je een #-symbool in de tekst gebruikt, wordt dit
geïnterpreteerd als het begin van een nieuwe regel. Wanneer de boodschap tekst start
met een punt of dubbele punt, wordt het geïnterpreteerd als een expressie. Verderop
volgt meer informatie over expressies. (Deze actie is niet werkzaam, wanneer je spel
wordt gerund in Exclusive mode, zie Hoofdstuk 20)

Set the score

Game Maker heeft een ingebouwd score mechanisme. De score wordt normaliter
getoond in het vensterhoofd. Deze actie kun je gebruiken om de score te wijzigen. Je
geeft de nieuwe scorewaarde.
Vaak zul je iets toe willen voegen aan de score. In dat geval dien je de Relative box aan
te vinken.

Display the higscore list

Deze actie laat de hoogste score lijst zien. Voor ieder spel wordt de top tien scores
bijgehouden.
Zij worden getoond in een lijst. Wanneer de huidige score in de top tien komt, wordt de
nieuwe score toegevoegd en de speler kan zijn /haar naam intypen.

31
Er bestaan vele manieren om de verschijningsvorm van de hoogste score lijst te
veranderen (zie Error: Reference source not found)
Deze actie werkt niet in de exclusive mode.

Set the number of lives

Game Maker heeft ook een ingebouwd Lives-systeem. Het aantal lives wordt getoond in
het hoofd, maar kan uitgezet worden. Met deze actie kun je het aantal lives dat over is
veranderen. Normaal zul je de waarde op ca. 3 aan het begin van het spel zetten en
deze waarde zal verlaagd of verhoogd worden, afhankelijk van wat er gebeurt. Vink de
Relative box aan wanneer je het aantal lives wilt verhogen of verminderen.
Wanneer het aantal lives 0 wordt (of kleiner dan 0) zal een ‘no more lives event’
gegenereerd worden.

Sleep for a while

Met deze actie kun je de scène een tijdje bevriezen. Dit wordt vaak gebruikt aan het
begin of eind van een level, wanneer je de speler een boodschap wilt meegeven. Je
specificeert het aantal milliseconden dat het spel wordt stilgelegd. Je moet ook
aangeven of het scherm opnieuw getekend moet worden om de meest recente situatie
weer te geven.

Go to the previous room

Beweeg naar de voorgaande kamer. Je kunt het soort overgangseffect tussen de
kamers aangeven. Experimenteer om te zien, wat het beste werkt. Wanneer je in de
eerste kamer bent, krijg je een foutmelding.

Go to the next room

Beweeg naar de volgende kamer. Je kunt de overgang aangeven.

Restart the current room

De huidige kamer wordt opnieuw opgestart. Je kunt de overgang aangeven.

Go to a different room
Met deze actie kun je naar een bepaalde kamer gaan. Je geeft aan naar welke kamer en
welk overgangseffect.

Restart the game

Met deze actie start je het spel weer op vanaf het begin.

End the game

Met deze actie wordt het spel beëindigd.

32
 Save the game
Met deze actie kun je de huidige spel status opslaan. Je specificeert de bestandsnaam
(het bestand wordt gecreëerd in de directory van het spel). Het spel kan later weer
opgestart worden met de volgende actie:

Load the game

Laad het spel in vanuit het bestand. Specificeer de bestandsnaam. Zorg ervoor dat het
opgeslagen bestand over hetzelfde spel gaat en gemaakt is in dezelfde versie van
Game Maker, zo niet dan volgt een foutmelding. Het spel wordt geladen aan het einde
van de huidige stap. Sommige acties na deze actie vinden niet in het geladen spel
plaats maar worden nog uitgevoerd in het huidige spel.

Show the game information

Met deze actie wordt het spel informatie scherm getoond. In Error: Reference source not
found vind je hierover meer informatie en ook over hoe je spel informatie creëert.

Switch fullscreen mode

Met deze actie kun je de schermstatus veranderen van een venster naar volledig
scherm en terug.
Je kunt kiezen om te schakelen tussen de beide modussen of om te gaan naar een
venster of fullscreen modus. (Dit werkt niet in exclusive mode.)

11.4 Vragen
Er zijn verschillende acties die een vraag stellen, bijvoorbeeld of een positie leeg is.
Wanneer het antwoord ja (true) is, wordt de volgende actie uitgevoerd; zo niet dan wordt
deze overgeslagen.
Wanneer je meerdere acties uitgevoerd wilt zien, dan wel overgeslagen afhankelijk van
de uitkomst, dan kun je deze acties bij elkaar stoppen in een block door start block en
end block acties rondom hen te zetten. Dus een vraag kan er als volgt uitzien:

33
In dit voorbeeld wordt de vraag gesteld of een positie voor de huidige instantie botsvrij
is. Zo ja, dan start de instantie in een bepaalde richting. Zo niet, dan springt de instantie
in een gegeven positie.

Voor alle vragen is er een veld, gelabeld NOT. Wanneer je dit veld aanvinkt, wordt het
resultaat van de vraag omgedraaid. Dus wanneer het resultaat true was, wordt dit false
en omgekeerd. Dit zorgt ervoor bepaalde acties te laten plaatsvinden, wanneer een
vraag niet juist is.

Voor vele vragen kun je instellen dat zij worden toegepast op alle instanties van een
object. Bijv. je kunt controleren of voor alle ballen de positie meer naar rechts collision
vrij is.

De volgende questions en gerelateerde acties zijn beschikbaar:

(Let erop dat zij allemaal een verschillend gevormd icoon hebben, waardoor zij
gemakkelijker van elkaar kunnen worden onderscheiden.)

If a position is collision free

Deze vraag wordt met true beantwoord, wanneer de huidige instantie, geplaatst op de
geïndiceerde positie geen collision genereert met een object. Je kunt de positie zowel
absoluut als relatief genereren.
Je kunt ook aangeven of dit alles alleen geldt voor solide objecten of voor alle objecten.
Deze actie wordt veelvuldig gebruikt om te controleren of een instantie naar een
bepaalde positie kan verplaatsen.

If there is a collision at a position

Dit is het omgekeerde van de voorgaande actie. Het geeft de waarde true terug,
wanneer er een botsing ontstaat als het huidige object naar een bepaalde gegeven
positie wordt verplaatst (opnieuw of voor solide objecten of voor alle objecten)

If there is an object at a position

Deze vraag wordt met true beantwoord, wanneer een instantie die geplaatst is op de
aangewezen positie een instantie van het aangewezen object ontmoet.

If the number of instances is a value

Je specificeert een object en een aantal. Wanneer het huidige aantal instanties van een
object gelijk is aan dit aantal, levert de vraag de waarde true op. In het andere geval
‘false’. Je kunt ook laten checken of het aantal instanties kleiner is dan een gegeven
waarde of hoger. Dit wordt bijv. gebruikt om te laten checken of alle instanties van een
bepaald type zijn verdwenen of niet. Meestal gebeurt dit op het moment dat een level
van een spel eindigt.

If a dice lands on one

Je specificeert het aantal zijden van de dobbelsteen. Wanneer de dobbelsteen op één
valt, is het resultaat ‘true’ en de actie wordt uitgevoerd. Dit kan gebruikt worden om een
random element in het spel in te bouwen. Bijv. in iedere stap wordt een bepaalde kans
gegenereerd waarmee een bewegingsrichting verandert of een bom valt. Hoe groter het

34
aantal zijden van de dobbelsteen is, hoe kleiner de kans. Je kunt reële getallen
gebruiken. Wanneer je het aantal zijden bijv. op 1.5 instelt, wordt de actie twee van de
drie keren uitgevoerd. Een getal meegeven dat kleiner is dan 1 heeft geen zin.

If a sound is playing
Het resultaat van deze vraag is ‘true
Wanneer de aangegeven sound wordt gespeeld.

If the user answers yes to a question

Je specificeert een vraag. Een dialog wordt getoond aan de speler met een jaknop en
een neeknop.
Het resultaat is ’true’ wanneer de speler ja antwoordt. Deze actie kan niet worden
gebruikt in de exclusive mode; dan is het antwoord altijd ja.

If an expression is true
Je kunt een expressie meegeven. Wanneer de expressie evalueert naar ‘true’ (een getal
groter of gelijk aan 0.5) wordt de volgende actie uitgevoerd. Hieronder vind je meer
informatie hierover.

If a mouse button is pressed

Geeft de waarde ‘true’ terug, wanneer de aangegeven muisknop wordt ingedrukt. Een
standaard gebruik is de step event. Je kunt checken of een muisknop is ingedrukt en
wanneer dat het geval is, bijv. naar die positie gaan (gebruik de jump to point actie met
waarden mouse_x en mouse_y)

If instance is aligned with grid

Geeft de waarde ‘true’ terug wanneer de positie van de instantie op het rooster ligt. Je
specificeert de horizontale en verticale ligging op het rooster. Dit is goed te gebruiken
wanneer bepaalde acties, bijv. een draai maken, alleen zijn toegestaan, wanneer de
instantie op het rooster ligt.

Else
Achter het actiedeel volgt het else gedeelte, dat wordt uitgevoerd wanneer het resultaat
van de vraag ‘false’ is.

Start of block
Geeft de start van een blok van acties aan.

End of block
Geeft het einde van een blok van acties aan.

35
 Repeat next action
Deze actie wordt gebruikt om de volgende actie te een aantal malen te herhalen (of een
blok van acties) . Je kunt simpelweg het aantal keren meegeven.

Exit the current event

Bij deze actie wordt geen enkele verdere actie in deze event meer uitgevoerd. Dit wordt
vaak gebruikt na een vraag. Bijv. wanneer een positie vrij is hoeft er niets gedaan te
worden en beëindigen we de event. In dit voorbeeld worden de volgende acties alleen
uitgevoerd, wanneer er een botsing optreedt.

11.5 Teken acties

Deze acties hebben alleen zin in de drawing event. Op alle andere plaatsen worden zij
genegeerd. Denk eraan dat het tekenen van andere dingen dan sprites en
achtergrondfiguren het spel relatief langzaam maakt. Gebruik deze acties dus alleen
wanneer het strikt noodzakelijk is.

Draw a sprite image

Je specificeert een sprite door de positie (absoluut of relatief in verhouding tot de huidige
instantie) en het plaatje (subplaatje) van de sprite (subplaatjes worden genummerd
vanaf 0 en hoger).
Wanneer je de volgende subplaatje wilt tekenen gebruik je nummer –1.

Draw a background image

Je geeft het achtergrond figuur mee door de positie te bepalen (absoluut of relatief) en of
het figuur verspreid moet worden over de hele kamer of slechts gedeeltelijk.

Draw a text
Je specificeert de tekst en de positie. Wanneer de tekst start met een punt of dubbele
punt, wordt het geïnterpreteerd als expressie.
Bijv. :

‘Score: ‘ + string(score)

om de waarde van de score mee te geven.

De variabele score bewaart de huidige score. De functie string() verandert dit aantal in
een string en combineert deze twee strings. Op een zelfde manier kun je het aantal
levens of een andere variabele tonen.

Set the font for drawing text

Hiermee bepaal je het lettertype dat wordt gebruikt om tekst te tonen.

36
 Draw a rectangle
Je specificeert de coördinaten van de twee tegenovergestelde hoeken van de rechthoek;
absoluut of relatief t.o.v. de huidige instantie positie.

Draw an ellipse
Je specificeert de coördinaten van de twee tegenovergestelde hoeken van de
omliggende rechthoek; absoluut of relatief t.o.v. de huidige instantie positie.

Draw a line
Je specificeert de coördinaten van de twee eindpunten van de lijn; absoluut of relatief
t.o.v. de huidige instantie positie.

Set the fill color

Hiermee kies je de vulkleur voor rechthoeken en ellipsen.

Set the line color

Hiermee kies je de kleur die gebruikt wordt als omlijning voor de rechthoeken en ellipsen
of wanneer je een lijn tekent.

11.6 Code gerelateerde acties

Tenslotte zijn er een aantal acties die je in code moet opnemen.

Execute a script
Met deze actie kun je een script uitvoeren dat je hebt meegegeven in het spel. Je
specificeert het script en de maximaal 3 argumenten voor het script. In Hoofdstuk 18
vind je meer informatie over scripts.

Set the value of a variable

Er zijn veel ingebouwde variabelen in het spel. Met deze actie kun je deze ingebouwde
variabelen veranderen. Je kunt ook eigen variabelen creëren en hen waarden
toekennen. Je specificeert de naam van de variabele en de nieuwe waarde ervan.
Wanneer je de Relative checkbox aanvinkt, wordt de waarde toegekend aan de huidige
waarde van de variabele. Denk eraan dat dit alleen mogelijk is wanneer de variabele al
een toegekende waarde heeft. Hieronder volgt meer informatie.

Execute a piece of code

Wanneer deze actie optreedt, wordt een formulier zichtbaar, waarin code kan worden
getypt. Het werkt op dezelfde manier als het definiëren van scripts (zie Hoofdstuk 18).
Het enige verschil is dat je kunt aangeven voor welke instanties de code werkzaam moet
zijn. Gebruik deze code actie alleen voor kleine stukjes code. Voor grotere stukken code
kun je beter gebruik maken van scripts.

37
 Call the inherited event
Deze actie is alleen zinvol wanneer het object overgeërfd is (zie Error: Reference source
not found).
Het roept het corresponderende event van het ouderobject aan.

Comment
Gebruik deze actie om een commentaarregel toe te voegen aan de actielijst. De zin
wordt getoond in italic font. Het doet niets wanneer de event wordt uitgevoerd.
Commentaar toevoegen helpt je te herinneren wat je events werkelijk doen.

11.7 Expressies en variabelen gebruiken

In veel acties is het nodig om waarden voor parameters mee te geven. In plaats van
alleen een aantal mee te geven, kun je ook een formule intypen, bijv. 32 * 12. Je kunt
ook veel gecompliceerdere expressies meegeven. Bijv. wanneer je de horizontale
snelheid wilt verdubbelen, kun je dit aangeven door 2*hspeed. De variabele hspeed geeft
de huidige horizontale snelheid weer van de instantie.
Er zijn een groot aantal variabelen die je kunt gebruiken. Een aantal van de meest
belangrijke zijn:

x de x-coördinaat van de instantie

y de y-coördinaat van de instantie
hspeed de horizontale snelheid (pixels per step)
vspeed de verticale snelheid (pixels per step)
direction de huidige bewegingsrichting in graden (0-360)
speed de huidige snelheid in deze richting
visible of een object zichtbaar(1) is of niet(0)
image_scale de grootte waarin de image is ingeschaald (1=not scaled)
image_single deze variabele geeft aan welke subplaatje in de huidige sprite
getoond moet worden; wanneer het ingesteld wordt op –1 (default) loop je door
de plaatjes heen, in het andere geval wordt de aangegeven subplaatje
(beginnend bij nummer 0) de hele tijd getoond.
score de huidige waarde van de score
lives het huidige aantal levens
mouse_x x-positie van de muis
mouse_y y-positie van de muis

Je kunt de meeste van deze variabelen wijzigen door de set variabele actie. Je kunt ook
je eigen variabelen definiëren door hen een waarde toe te kennen gebruik geen relatieve
omdat ze nog niet bestaan. Je kunt deze variabelen vervolgens gebruiken in expressies.
De variabelen die je op deze manier creëert zijn lokale variabelen voor de huidige
instantie. Ieder object heeft een eigen kopie ervan. Om een globale variabele te creëren
moet je het woord global en een punt ervoor zetten.

Je kunt refereren aan de waarden van de variabelen voor andere objecten door de
objectnaam en een punt ervoor te zetten. Bijv. wanneer je een bal wilt laten bewegen
naar de plaats waar de munt is, kun je de positie als volgt aangeven (coin.x, coin.y). In
het geval van een collision event, kun je refereren aan de x-coördinaat van de andere
objecten door other.x te schrijven.

38
In conditionele expressie kun je gebruik maken van vergelijkingen als <, >, enz.

In je expressies kun je ook gebruik maken van functies. Bijv. de functie random (10) geeft
een random reëel getal onder de 10 aan. Je kunt zo bijv. de snelheid van de
bewegingsrichting instellen op een random waarde. Veel meer functies bestaan. In
Hoofdstuk 23 vind je meer informatie over expressies en functies.

39
Hoofdstuk 12 Het maken van rooms
Nu je voorwerpen met hun gedrag in de vorm van gebeurtenissen en acties hebt
bepaald, is het tijd om de rooms of de levels te creëren waarin het spel plaatsvindt. Elk
spel heeft minstens één room. In deze rooms plaatsen wij instanties van de objecten.
Zodra het spel begint wordt de eerste room getoond en de instanties daarin komen tot
leven door de acties in hun creation event.

Om een room te creëren, kies Add Room van het Add menu. Het volgende formulier
zal verschijnen:

Aan de linkerzijde vindt je bepaalde instellingen voor de room. Zoals gewoonlijk is er een
Standard tab en een Advanced tab. Wij zullen hier slechts de standaard commando’s
bespreken. (Voor de geavanceerde opties zie Error: Reference source not found.)

Elke room heeft een naam. Je kunt hem het beste een zinvolle naam geven. Er is ook
een titel. Deze titel wordt getoond in de venstertitel wanneer het spel loopt. Je kunt de
breedte en de hoogte van de room (in pixel) bepalen. Maak deze niet te groot. Het zal
het spel vertragen en zal veel resources vergen. Ook kan je de snelheid van het spel
bepalen. Dit is het aantal stappen per seconde. Hoe hoger de snelheid, hoe vloeiender
de beweging. Maar je zult een snelle computer nodig hebben om het spel te spelen.

Om instanties aan de room toe te voegen, selecteert je eerst het object links onderaan.
Nu klik je met je muis in het room-gebied rechts. Een instantie van het object verschijnt.
Het zal zich op het raster uitlijnen. Je kunt het raster in de toolbar aanpassen. Ook kan

40
je daar op aangeven of je al dan niet rasterlijnen wilt tekenen. Met de rechter muisknop
kun je instanties verwijderen. Op deze wijze bepaal je de inhoud van de ruimte. Als je de
muisknop ingedrukt houdt, worden meerdere instanties toegevoegd of verwijderd.

Zoals je zult opmerken, verdwijnt de originele instantie als je een instantie boven op een
andere plaatst. Meestal is dit wat je wilt, maar niet altijd. Het kan worden vermeden door
het indrukken van de <Ctrl>toets tijdens het plaatsen van de instantie. Er zijn nog drie
nuttige toetscombinaties voor als je te maken hebt met overlappende instanties.
Wanneer je <Ctrl> ingedrukt houdt bij het klikken op een instantie met de rechter
muisknop, wordt de onderste instantie naar de bovenste positie verplaatst. Het ingedrukt
houden van <Alt> zal de bovenste instantie naar de onderste positie verplaatsen. Dit kan
worden gebruikt om de volgorde van overlappende instanties te veranderen. Tenslotte,
ingedrukt houden van <Shift> terwijl je klikt met de rechter muisknop zal alle instanties
op deze positie verwijderen, niet alleen de bovenste.

Op de toolbar zul je een aantal knoppen vinden om alle instanties in één van de vier
richtingen te verplaatsen. Dit is bijvoorbeeld nuttig als je de room wilt vergroten. (Je kan
dit ook gebruiken om instanties buiten de room te plaatsen, wat soms nuttig is.) Ook is
er een knop om de room leeg te maken.

Met de knop Background kan je het achtergrondplaatje van de room kiezen. Je kan
zelfs een aantal verschillende achtergrondplaatjes kiezen. Het volgende formulier laat dit
zien:

Aan de bovenkant zie je de achtergrondkleur. Je kunt er op klikken om het te

veranderen. Een kleur als achtergrond is slechts nuttig als je geen achtergrondplaatje
gebruikt dat de gehele achtergrond bedekt. Anders kun je beter de Draw background
color afvinken, want het kost dan alleen maar tijd.

Aan de linkerzijde zie je een lijst van 8 achtergronden. Je kan ze allemaal definiëren
maar je zal er meestal maar één of twee nodig hebben. Om een achtergrond te
definiëren, selecteer je hem eerst in de lijst. Vervolgens klik je Visible when room
starts aan, anders kun je het niet zien. De naam van de achtergrond zal vet worden
wanneer hij wordt gedefinieerd. Kies nu op een achtergrondplaatje in het menu. Er zijn

41
een aantal instellingen die je kunt aanpassen. Ten eerste kan je aangeven of het
achtergrondplaatje horizontaal en/of verticaal betegeld moet worden. Je kunt ook de
positie van de achtergrond in de room bepalen (dit zal ook het betegelen beïnvloeden).
Tenslotte kan je de achtergrond laten scrollen door hem een horizontale of verticale
snelheid te geven

Er is nog één checkbox: Foreground image. Wanneer je deze checkbox aanvinkt,

wordt de achtergrond eigenlijk een voorgrond, die voor al het andere wordt getekend.
Zo’n plaatje zal natuurlijk gedeeltelijk doorzichtig moeten zijn om van enig nut te zijn.

Een goed gebruik van achtergrond- en voorgrondplaatjes kan je spel veel mooier
maken. Zoals je in Error: Reference source not found zult zien, kunnen achtergronden
ook worden gebruikt om statische objecten in op te slaan.

42
Hoofdstuk 13 Meer over sprites
Tot nu toe hebben we de sprites steeds uit bestanden geladen. Het is echter ook
mogelijk om ze te maken en te wijzigen binnen Game Maker. Dit doe je door te
dubbelklikken op een sprite (of door een nieuwe te maken); het sprite
eigenschappenvenster zal verschijnen. Klik nu op Edit Sprite. Een nieuw formulier zal
verschijnen met daarin alle subplaatjes waaruit sprite is opgebouwd.

13.1 Sprites editen

De sprite editor ziet er als volgt uit:

Rechts zie je de verschillende plaatjes van de sprite. Merk op dat in Game Maker alle
subplaatjes van een sprite dezelfde grootte moeten hebben. Aan de linkerzijde zie je
hoe de geanimeerde sprite eruit ziet. (Als je de animatie niet ziet, vink dan Show
Preview aan.) Onder de preview kan je de snelheid van de animatie en de
achtergrondkleur instellen. Op deze wijze krijg je een idee van de animatie in de
spelsituatie.

De sprite editor bevat vele commando’s om een sprite te maken en te veranderen. Dit
gebeurt allemaal via menu’s. (Voor sommige zijn er knoppen op de toolbar.) Sommige
commando’s bewerken op individuele plaatjes. Hiervoor moet je eerst een subplaatje
met de muis selecteren.

13.1.1 File menu

Het bestandsmenu bevat een aantal commando’s die betrekking hebben op het laden
en opslaan van sprites.

 New. Creëert een nieuwe, lege sprite. Je moet de grootte van de sprite instellen.
(Denk eraan dat alle plaatjes van een sprite dezelfde grootte moeten hebben.)

43
  Create from file. Maak een sprite uit een bestand. Vele bestandtypes kunnen
worden gebruikt. Op deze manier maak je een sprite die uit één enkel plaatje
bestaat, behalve als je geanimeerde GIF-bestanden gebruikt die in subplaatjes
verdeeld zijn. Merk op dat Game Maker niet met geoptimaliseerde geanimeerd
GIF-bestanden overweg kan! Merk ook op dat de transparantiekleur de kleur is
van de pixel die zich helemaal linksonder in het plaatje bevindt, niet de
transparantiekleur van het GIF-bestand.
 Add from file. Voeg een plaatje (of plaatjes) uit een bestand toe aan de huidige
sprite. Als de plaatjes niet dezelfde grootte hebben kunt je kiezen waar ze neer
wil zetten of dat je ze uit wil rekken.
 Save as GIF. Slaat de sprite op als een geanimeerd gif-je.
 Save as strip. Slaat de sprite op als bitmap, met alle plaatjes naast elkaar.
 Create from strip. Hiermee kan je sprites vanuit een strip maken. Zie hieronder
voor meer informatie.
 Add from strip. Gebruik dit om plaatjes vanuit een strip toe te voegen. Zie
hieronder.
 Close saving changes. Sluit het formulier, veranderingen worden opgeslagen.
Als je de veranderingen niet wilt bewaren, klik op de afsluitknop van het venster.

13.1.2 Edit menu

Het edit menu bevat een aantal commando’s die betrekking hebben op de huidig
geselecteerde sprite. Je kunt hem knippen naar het klembord, een plaatje van het
klembord plakken, de huidige sprite leegmaken of verwijderen, en sprites naar links en
rechts in de opeenvolging verschuiven. Tenslotte is er een commando om een
individueel plaatje te bewerken in het ingebouwde tekenprogramma. Zie hieronder.

13.1.3 Transform menu

In het transform menu kan je een aantal transformaties op de plaatjes uitvoeren.

 Mirror horizontal. Horizontaal spiegelen van de plaatjes.

 Flip vertical. Verticaal spiegelen van de plaatjes.
 Shift. Hier kan je de plaatjes horizontaal en verticaal verplaatsen over een
bepaalde waarde.
 Rotate. Je kunt de plaatjes 90 graden, 180 graden, of een willekeurig aantal
graden roteren. In het laatst geval kan je ook de kwaliteit bepalen. Experimenteer
voor de beste resultaten.
 Resize Canvas. Hier kan je de grootte van het canvas veranderen. Je kunt
aangeven waar de oude plaatjes op het nieuwe canvas worden geplaatst.
 Stretch. Hier kan je de plaatjes tot een nieuwe grootte uitrekken. Je kunt de
schaal en de kwaliteit aangeven.
 Scale. Dit commando schaalt de plaatjes (maar niet de beeldgrootte!). Je kunt de
schaal, de kwaliteit, en de positie van de huidige plaatjes aangeven.

13.1.4 Images menu

In het images menu kan je een aantal operaties op de plaatjes uitvoeren.

 Cycle left. Verschuif alle plaatjes één plaats naar de linkerzijde. Hierdoor begint
de animatie op een ander punt.
 Cycle right. Verschuif alle plaatjes één plaats naar rechts.

44
  Black and white. Maakt een sprite zwart wit (beïnvloedt de kleur van de
transparantie niet!).
 Colorize. Hier kan je de kleur (tinten) van de plaatjes veranderen. Gebruik de
schuifbalk om de verschillende kleuren te kiezen.
 Intensity. Hier kan je de intensiteit veranderen door waarden voor de
kleurenverzadiging en de lichtheid van de plaatjes te verstrekken.
 Fade. Hier bepaal je een kleur en een waarde. De kleuren in de plaatjes
veranderen nu langzaam naar deze kleur.
 Transparency. Hier kan je het niveau van schermdeur transparantie aangeven.
Dit wordt bereikt door een aantal pixel doorzichtig te maken.
 Blur. Om de plaatjes te vertroebelen worden de kleuren een beetje gemengd,
zodat het vager wordt. Hoe hoger de waarde, hoe vager het wordt.
 Crop. Dit maakt de plaatjes zo klein mogelijk. Dit is zeer nuttig omdat hoe groter
de beelden, hoe meer videogeheugen het spel zal gebruiken. Je kunt een kader
aangeven rond het plaatje om een transparantie probleem te vermijden.

U zult met deze commando’s moeten experimenteren om sprites te krijgen zoals jij ze
wilt.

13.1.5 Animation menu

In het animation menu kan je nieuwe animaties maken uit de huidige animaties. Er zijn
vele opties en je zou er een beetje mee moeten experimenteren om de effecten te
maken die je wilt. Vergeet ook niet dat je een animatie altijd kunt opslaan en later aan de
huidige animatie kunt toevoegen. Ook kan je altijd een aantal lege plaatjes toevoegen en
ongewenste schrappen. Ik zal kort de verschillende mogelijkheden aangeven.

 Set Length. Hier kan je de lengte van je animatie veranderen. De animatie wordt
vaak genoeg herhaald om het aantal frames te creëren je aangeeft. (Normaal wilt
je dat dit een veelvoud van het huidige aantal frames zal zijn.)
 Stretch. Dit bevel verandert ook de lengte van de animatie. Maar deze keer,
worden frames verdubbeld of verwijderd om het juiste aantal te krijgen. Als je het
aantal frames verhoogt gaat de animatie langzamer en als je het aantal
vermindert het sneller gaat.
 Reverse. Zoals te verwachten keert dit commando de animatie om. Hij wordt dus
achterstevoren afgespeeld..
 Add Reverse. Dit keer wordt de omgekeerde animatie toegevoegd, hierdoor
verdubbeld het aantal kaders. Dit is zeer nuttig om een voorwerp naar links en
rechts te laten gaan, de kleur te veranderen en weer terug te gaan, enz..
Misschien wil je wel het dubbele eerste en middelste frame die zo ontstaan
verwijderen.
 Translation sequence. Je kunt een animatie maken waarin het plaatje een klein
beetje verplaatst bij elke stap. Je moet het aantal frames aangeven en de totale
waarde van de horizontale en verticale beweging.
 Rotation sequence. Creëert een animatie waarin het plaatje roteert. Je kunt of
omwenteling met de wijzers van de klok mee kiezen of tegen de klok in. Bepaal
het aantal frames en de totale hoek in graden (360 is een volledige draai). Je
moet misschien de grootte van het canvas aanpassen om ervoor te zorgen het
totale plaatje tijdens de omwenteling zichtbaar blijft.
 Colorize. Creëert een animatie die het plaatje in een bepaalde kleur verandert.

45
  Fade to color. Creëert een animatie die het plaatje langzaam in een bepaalde
kleur verandert.
 Disappear. Laat het plaatje verdwijnen met behulp van schermdeur
transparantie.
 Shrink. Krimpt het plaatje tot er niets overblijft. Je kunt de richting aangeven.
 Grow. Laat het plaatje groeien vanuit niets.
 Flatten Vlakt het plaatje uit tot niets in een bepaalde richting.
 Raise. Laat het plaatje groeien vanuit een bepaalde richting.
 Overlay. Bedekt de animatie met een andere animatie of plaatje uit een bestand.
 Morph. ‘Morft’ de animatie naar een animatie of plaatje uit een bestand. Merk op
dat dit ‘morfen’ het best werkt als de twee animatie hetzelfde gebied van het
plaatje gebruiken. Anders verdwijnen halverwege de animatie bepaalde pixels en
andere verschijnen plotseling.

In het bijzonder zijn de laatste twee commando’s zeer krachtig. Bijvoorbeeld, om een
voorwerp op te blazen, voeg je een aantal exemplaren toe en een aantal lege kaders.
Gebruik dan het commando overlay met een animatie van een explosie. (Zorg ervoor
dat het aantal plaatjes klopt.) Een andere manier om dit te doen is je animatie ‘morfen’
naar een animatie van een explosie. Met wat praktijkoefening kunt je geweldige sprites
maken.

13.1.6 Strips
Zoals hierboven al vermeld, worden sprites normaal opgeslagen als geanimeerde GIF-
dossiers of als strips. Een strip is één grote bitmap die alle plaatjes naast elkaar opslaat.
Het enige probleem is dat de grootte van individuele subplaatjes niet in het plaatje wordt
opgeslagen. Daarbij komt dat vele stripbestanden die te vinden zijn op het internet
meerdere sprites opslaan in één bestand. Bijvoorbeeld, het volgende stuk van een
stripbestand bevat vier verschillende animaties.

Om individuele sprites uit dergelijke bestanden te selecteren, kun je kiezen voor Create
from Strip of Add from Strip van het File menu. Na aangeven van het juiste
stripbestand zal het volgende formulier naar voren komen:

46
Rechts zie je (een deel van) het stripplaatje dat je selecteerde. Aan de linkerzijde kan je
een aantal parameters opgeven die aangeven in welke subplaatjes je geïnteresseerd
bent. Merk op dat één of meerdere rechthoeken in het plaatje aangeven welke plaatjes
zijn geselecteerd. De volgende parameters kunnen worden opgegeven:

 Number of images. Dit is het aantal plaatjes dat je uit de strook wilt nemen.
 Images per row. Hoeveel van de plaatjes die jij wilt staan er per rij. Bijvoorbeeld,
door dit op 1 te zetten zult je een verticale opeenvolging van plaatjes selecteren.
 Image width. Breedte van de individuele beelden.
 Image height. Hoogte individuele beelden.
 Horizontal cell offset. Als je niet de plaatjes linksboven wilt selecteren, kan je
hier aangeven hoeveel plaatjes horizontaal zouden moeten worden
overgeslagen.
 Vertical cell offset. Hier geef je aan hoeveel plaatjes verticaal over te slaan.
 Horizontal pixel offset. Soms is er wat extra ruimte bij de linkerbovenkant. Hier
geef je dit aantal aan (in pixels).
 Vertical pixel offset. Verticale hoeveelheid extra ruimte.
 Horizontal separation. In sommige strips zijn er lijnen of lege ruimtes tussen de
plaatjes. Hier kan je de horizontale waarde aangeven om tussen de plaatjes (in
pixel) over te slaan.
 Vertical separation. Verticale waarde om tussen de plaatjes over te slaan.

Zodra je de correcte reeks plaatjes geselecteerd hebt, klik je op OK om je sprite te

creëren. Denk er alsjeblieft aan dat je plaatjes die door anderen zijn gemaakt slechts
mag gebruiken wanneer je hun toestemming hebt of wanneer ze freeware zijn.

47
13.2 Individuele subplaatjes editen
U kunt de individuele subplaatjes ook bewerken. Daartoe selecteer je een subplaatje en
kies je Edit Image van het Image menu. Dit zal een ingebouwd
beeldbewerkingprogrammaatje openen. Realiseer je wel dat dit een beperkt programma
is dat hoofdzakelijk gemaakt is om kleine veranderingen in bestaande plaatjes aan te
brengen en niet om nieuwe plaatjes te ontwerpen. Daarvoor kun je beter een volledig
tekenprogramma gebruiken en gebruik bestanden (of kopiëren en plakken) om het
plaatje in Game Maker te krijgen.

Het formulier hierboven toont het plaatje in het midden en een aantal
basistekenknoppen aan de linkerzijde. Hier kan je in en uitzoomen, pixel, lijnen en
rechthoeken tekenen, tekst plaatsen, enz.. Merk op dat de kleur afhangt van het feit of je
de linker of rechter muisknop gebruikt. Voor sommige tekeninstrumenten kunnen je
eigenschappen instellen (zoals lijnbreedte of zichtbaarheid van de omtrek). Er is een
speciale knop die alle pixel van een bepaalde kleur verandert in een andere kleur. Dit is
in het bijzonder nuttig om de achtergrondkleur te veranderen die voor transparantie
wordt gebruikt. Op de toolbar staan een aantal speciale knoppen om alle pixels in het
plaatje in een bepaalde richting te bewegen. Ook kan je aangeven om een rooster te
tonen wanneer het plaatje wordt gezoomd (dit werkt alleen bij een zoomfactor van
minstens 4).

Rechts in de figuur kan je de te gebruiken kleuren selecteren (één voor de

linkermuisknop en één voor de rechter). Er zijn vier manieren om de kleur te veranderen.
Ten eerste kun je met de muisknop (links of rechts) in één van de 16 basiskleuren
klikken. Merk op dat er een speciaal kleurvakje is die de kleur van de pixel linksonder in

48
het plaatje aangeeft, deze kleur wordt gebruikt als transparantiekleur als de sprite
doorzichtig is. Je kunt deze kleur gebruiken om een deel van je plaatje doorzichtig te
maken. De tweede manier is in het plaatje met de veranderende kleur te klikken. Hier
kun veel meer kleurenkiezen. Je kunt de muisknop constant ingedrukt houden om de
kleur te zien die je selecteert. Ten derde, kun je met de linkermuis in de box klikken die
de linker en rechter kleur aangeven. Een kleurendialoogvenster komt in beeld waarin je
de kleur kunt selecteren. Tenslotte kun je aan de linkerzijde het kleurendruppelbuisje
selecteren en op een positie in het plaatje klikken om die kleur te kopiëren.

In deze menu's zal je dezelfde transformatie en edit commando’s aantreffen die ook
beschikbaar zijn in de sprite editor. Dit keer zijn ze echter slechts op het huidige plaatje
van toepassing. (Wanneer een sprite meerdere plaatjes bevat, zijn commando’s die
verandering van de grootte teweeg brengen, zoals stretch, niet beschikbaar. Je kunt het
plaatje ook als bitmap bewaren. Er zijn twee extra commando’s in het Image menu:

 Clear. Maak het plaatje leeg met de linkerkleur (die dan automatisch de kleur
van de transparantie wordt).
 Gradient fill. Met dit commando kan je het plaatje vullen met een geleidelijk aan
veranderende kleur (niet erg nuttig om sprites te maken, maar het ziet er aardig
uit, en kan voor achtergronden worden gebruikt, die hetzelfde programma
gebruiken).

Merk op dat er geen mechanisme is om delen van het plaatje te selecteren. Ook missen
we een aantal prettige tekenroutines. Hiervoor zou je meer geavanceerd
tekenprogramma moeten gebruiken (of eenvoudig het ‘paint’ dat in windows zit). De
gemakkelijkste manier om dit te doen is de kopiëerknop te gebruiken om zo het plaatje
op het klembord te zetten. Daarna kan je in Game Maker het gewijzigde plaatje weer
plakken.

13.3 Geavanceerde sprite instellingen

In het sprite eigenschappenformulier is een Avanced tab. Hier vind je een aantal
geavanceerde opties die wij hier zullen behandelen.

Ten eerste zijn er opties met betrekking tot het controleren van botsingen. Telkens
wanneer twee instanties samenkomen wordt een collision event gegenereerd. De
botsingen worden gecontroleerd op de volgende manier. Elke sprite heeft een bounding
box. Deze box is dusdanig dat het ondoorzichtige deel van alle subplaatjes bevat.
Wanneer de bounding boxen overlappen, wordt er gecontroleerd of twee pixel in de
huidige subplaatjes van twee sprites overlappen. Deze tweede verrichting is moeizaam
en vereist extra geheugen en voorbewerken. Dus als je niet geïnteresseerd bent in het
nauwkeurige controleren van botsingen tussen sprites, kan je beter het vakje Precise
collision checking niet aanvinken. In dat geval wordt slechts gecontroleerd op het
overlappen van bounding boxen. Je kunt de bounding box ook veranderen. Dit is haast
nooit nodig, maar soms wil je de bounding box kleiner maken, zodat dat de botsingen
met sommige uitstekende delen van de sprite niet in acht worden genomen.

Sprites kunnen op twee plaatsen worden opgeslagen: video geheugen en

standaardgeheugen. Het videogeheugen is normaal aanwezig op de grafische kaart en
is sneller. Dus als je vele instanties van een sprite hebt, wil je het liever daar op te slaan.
Maar de hoeveelheid videogeheugen is beperkt, afhankelijk van de grafische kaart die

49
de speler heeft. Het is dus aanbevolen om grote sprites niet in het videogeheugen op te
slaan.

Sommige sprites wilt je in slechts één of twee levels van je spel kunnen gebruiken. Het
is een beetje zonde om deze sprites steeds in het geheugen te houden. In dit geval kan
je Load only on use aanvinken. De sprite wordt nu geladen op het eerste moment
waarop het wordt vereist. Aan het eind van het level wordt het weer uit het geheugen
gegooid om zo weer ruimte vrij te maken. Voor grote spelen met vele sprites is het
belangrijk zorgvuldig te kiezen welke sprites worden geladen en welke in het
videogeheugen worden opgeslagen.

Tenslotte, kunt je op de oorsprong van de sprite aangeven. Dit is het punt in sprite die
overeenkomt met zijn positie. Wanneer je een instantie op een bepaalde positie plaatst,
wordt de oorsprong van de sprite daar geplaatst. Normaal gesproken is de oorsprong de
linkerbovenhoek van de sprite, maar het is soms geschikter om het midden of een ander
belangrijk punt te gebruiken. Je kunt zelfs een oorsprong buiten de sprite kiezen.

50
Hoofdstuk 14 Meer over geluiden en muziek
Wanneer je geluid aan je spel toevoegt zijn er een aantal andere aspecten die je kunt
aangeven. Deze kun je vinden onder de geavanceerde tab in het muziek
eigenschappenformulier.

Voor alle geluiden kunt je aangeven of zij alleen bij gebruik moeten worden geladen. Dit
is de standaard instelling voor midibestanden maar niet voor wavebestanden. Als je
deze optie aanvinkt, wordt het geluid niet geladen in het geheugen wanneer het spel
begint. Slechts op het ogenblik dat het nodig is, wordt het geladen. Dit zou een lichte tik
kunnen geven. Maar bespaart heel wat geheugen en dat betekent dat het spel sneller
geladen wordt. Aan het eind van het level wordt het geluid weer weggegooid en het
geheugen vrijgegeven. Slechts als het opnieuw wordt vereist wordt het opnieuw
geladen. Gebruik dit niet voor slechts korte geluidseffecten, maar voor langere
achtergrondmuziek of fragmenten niet die slechts nu en dan worden gespeeld.

Voor wave bestanden kan je het aantal buffers opgeven. Deze waarde geeft aan hoe
vaak je het geluid tegelijk (simultaan)kunt afspelen. Bijvoorbeeld, wanneer je één of
ander exploderend geluid hebt en een aantal explosies op bijna hetzelfde moment, zou
je dit aantal kunnen verhogen zodat dat alle explosies gelijktijdig te horen zijn. Ga er
echter zorgvuldig mee om. Meerdere buffers kosten (afhankelijk van de geluidskaart)
meer geheugen.

Ook kan je aangeven of het geluid op effecten moet worden voorbereid. Deze effecten,
zoals het filteren van het geluid en het veranderen van het volume, kunnen slechts door
code worden aangegeven. De geluiden die voorzien worden van effecten hebben meer
resources nodig.

Er is ook een knop om het geluid in een bestand op te slaan. Dit is nuttig als je het
oorspronkelijke geluidsbestand verloren hebt en het geluid voor iets anders wilt
gebruiken.

Naast wavebestanden en midibestanden, is er ook een derde soort geluidsformaat:

mp3bestanden. Dit zijn samengeperste wavebestanden. Hoewel je ze niet ziet bij het
selecteren van een geluidsbestand kan je ze wel gebruiken in Game Maker. Geef eerst
aan dat je alle bestandtypen wilt zien in het file open formulier, dan kun je ze laden.
Niettemin moet je er zorgvuldig mee omgaan. Er zijn een namelijk een aantal nadelen.
Ten eerste moeten ze worden gedecomprimeerd en dat vergt tijd die het spel zou
kunnen vertragen. Het feit dat de bestandsgrootte kleiner is betekent niet dat zij minder
geheugen gebruiken. Ten tweede, niet alle machines ondersteunen mp3. Hierdoor zou
je spel niet op alle machines kunnen lopen. Gebruik mp3bestanden bij voorkeur dus
niet, maar zet ze op in wavebestanden. Als je ze toch wilt gebruiken, gebruik ze dan
slechts als achtergrondmuziek.

51
Hoofdstuk 15 Meer over achtergronden
Naast het laden van uit een bestand, kun je achtergronden ook zelf maken. Daartoe klik
je op Edit Background. Een klein ingebouwd tekenprogramma wordt geopend waarin je
je achtergrond kunt maken of veranderen. Houd er rekening mee dat dit geen
volwaardig programma is. Voor meer geavanceerde mogelijkheden moet je een ander
tekenprogramma gebruiken. Het ingebouwde tekenprogramma wordt beschreven in
13.2. Er is één optie die bijzonder nuttig is. In het Image menu vind je een commando
Gradient Fill. Dit kan worden gebruikt om een leuke achtergronden met kleurverloop te
creëren.

Ook het achtergrond eigenschappenformulier heeft een Avanced tab. Hier zijn een
aantal geavanceerde aspecten van achtergronden beschikbaar.

Normaal worden de achtergronden opgeslagen in videogeheugen. Dit is prima wanneer

zij klein zijn maar wanneer je grote achtergronden gebruikt wil je misschien normaal
geheugen kunnen gebruiken. Dit zal iets langzamer zijn, maar het videogeheugen is
beperkt. Vink hiervoor Use video memory niet aan.

Achtergronden worden ook pas geladen wanneer zij worden vereist en ook aan het eind
van de room weggedaan. Dit bespaart heel wat geheugen maar zal de start van room
lichtelijk langzamer maken en kan een kleine tik geven wanneer halverwege een level
de achtergrond van een room verandert. Om dit te vermijden moet je Load only on use
niet aanvinken.

15.1 Getegelde achtergronden maken

U kunt ook de zogenaamde betegelde achtergronden creëren. De reden voor dit is als
volgt: in vele spelen wilt je mooi ogende achtergronden hebben. Bijvoorbeeld, in een
labyrintspel, zouden de muren van het labyrint keurig omhoog moeten lopen, en in
platformspel houdt je van prachtig getekende ruimtes, bomen, enz. Je kunt dit in Game
Maker realiseren door veel verschillende voorwerpen te bepalen en je rooms met deze
voorwerpen samen te stellen. Het probleem is niettemin dat dit heel wat werk vergt,
grote hoeveelheden geheugen gebruikt, en de spelen wegens de vele verschillende
voorwerpen langzaam maakt. Bijvoorbeeld, om aardige muren in labyrintspelen te
creëren hebt je reeds 15 verschillend gevormde muurvoorwerpen nodig.

De standaarduitweg, die in vele spelen wordt gebruikt, is dat de muren en andere

statische voorwerpen eigenlijk op de achtergrond worden getekend. Maar je zou kunnen
vragen, hoe weet het spel dat een voorwerp een muur raakt als het op de achtergrond
wordt getekend? De truc is als volgt: Je creëert enkel één muurvoorwerp in je spel. Het
moet de juiste grootte hebben maar het hoeft er niet aardig uit te zien. Bij het creëren
van de ruimte, plaatst je dit voorwerp op alle plaatsen waar er een muur is. En, hier komt
de truc, maken wij dit voorwerp onzichtbaar. Bij het spelen van het spel ziet je de
muurvoorwerpen niet. In plaats daarvan zie je de mooie achtergrond. Maar de stevige
muurvoorwerpen zijn er nog en het voorwerp in het spel zal er op reageren.

U kunt deze techniek voor om het even welk voorwerp gebruiken dat zijn vorm of positie
niet verandert. (Je kunt het niet gebruiken wanneer het voorwerp moet worden
geanimeerd.) Voor platformspelen, hebt je enkel waarschijnlijk één vloer en één

52
muurvoorwerp nodig, maar je kunt prachtig laten lijken door de achtergronden waarbij
het lijkt alsof je op gras, op boomtakken, enz. loopt.

Om een dergelijke betegelde achtergrond te creëren, druk op de knop Create with tiles.
Het volgende scherm zal zich tonen (eigenlijk, voegden wij reeds sommige tegels in
deze vorm toe).

In de linkerbovenkant is een overzicht van de huidige reeks gebruikte tegels. Je kunt

verschillende tegelreeksen laden door op de knop Tile Set te drukken. Een aantal
nuttige reeksen zijn door Game Maker mee geleverd: onder het overzicht kunt je een
aantal instellingen veranderen. Je kunt de breedte en de hoogte van de achtergrond, de
kleur bepalen die als achtergrond achter de tegels (die normaal als kleur van de
transparantie) wordt gebruikt aangeven, en hoe de tegels op het raster moeten passen.

Om een tegel in het achtergrondplaatje te plaatsen, selecteer het in de tegelreeks.

Volgende klik met je linkermuis op de achtergrond, en de tegel verschijnt. Wis het (in de
achtergrondkleur) gebruiken dan de rechtermuisknop. Sommige speciale combinaties
kunnen worden gebruikt:

 Holding < Ctrl > zal de tegel horizontaal spiegelen

 Holding < Alt > zal de tegel verticaal spiegelen
 Holding < Shift> zal de grootte van de tegel verdubbelen

Je kunt om het even welke combinatie deze drie gebruiken.

Zodra je achtergrond klaar is, klik je op OK om hem te saven.

53
Vaak wil je je betegelde achtergrond van een andere achtergrond voorzien. Zoals je zou
moeten weten, kan dit worden bereikt door twee achtergronden in je rooms te gebruiken.
Maak de betegelde achtergrond in dit geval doorzichtig. (Het programma zal ervoor
zorgen dat altijd het linkerbodem pixel van de betegelde achtergrond de
achtergrondkleur heeft, zo dat dit correct werkt.

U kunt je eigen tegelreeksen aan Game Maker toevoegen. Een tegelreeks is een
eenvoudig bitmap bestand dat alle tegels opslaat. Tussen om het even welke twee
tegels is er één brede lijn van het een pixel. Al deze separatorlijnen moeten de kleur
hebben die voor transparantie in de tegelreeks wordt gebruikt. (Als reële kleur van de
transparantie wordt de kleur van het lagere uiterst linkse pixel in het plaatje gebruikt. De
naam van het tegelreeksbestand is essentieel. Zij moeten in _ wwwxhhh
beëindigen.bmp, waar www de breedte en hhh de hoogte tegels in pixel is. Zo
bijvoorbeeld, een dossier genoemd examples_32x16. bmp bevat tegels van breedte 32
en hoogte 16. In sommige gevallen zou je tegelbeelden kunnen hebben die de 1-pixel
separatorlijnen niet hebben. Deze kunnen eveneens worden gebruikt. In dat geval moet
de bestandsnaam de letter n aan het eind hebben. Bijvoorbeeld examples_32x16n.bmp.

54
Hoofdstuk 16 Meer over objecten
Wanneer je een voorwerp creëert, kan je wat meer geavanceerde settings verander in
het tabblad Advanced.

16.1 Depth
Ten eerste, kunt je de diepte van de instanties van het voorwerp instellen. Wanneer de
instanties op het scherm worden getekend worden zij getekend in volgorde van diepte.
De instanties met de grootste diepte worden eerst getrokken. De instanties met de
kleinste diepte worden het laatst getrokken. Wanneer de instanties dezelfde diepte
hebben, worden zij getrokken in de orde waarin zij werden gecreëerd. Als je wilt
waarborgen dat een voorwerp voor ligt geef dan de anderen een negatieve diepte. Als je
ervoor wilt zorgen het onder andere instanties ligt, geeft het dan een grote positieve
diepte. Je kunt de diepte van een instantie tijdens het spel ook veranderen gebruik
makend van de variable depth.

16.2 Persistent objects

Ten tweede, kunt je een voorwerp blijvend maken. Een blijvend voorwerp zal blijven
bestaan wanneer je zich van één room naar de volgende beweegt. Het verdwijnt slechts
wanneer je het uitdrukkelijk vernietigt. Zo moet je het voorwerp in de eerste room zetten
en dan zal het beschikbaar zijn in alle rooms. Dit is prettig wanneer je bijvoorbeeld een
hoofdfiguur hebt die zich van room naar room beweegt. Het gebruiken van blijvende
voorwerpen is een krachtig mechanisme maar ook één die gemakkelijk tot fouten leidt.

16.3 Parents
Elk voorwerp kan een oudervoorwerp hebben. Wanneer een voorwerp een ouder heeft,
erft het het gedrag van de ouder. Anders verklaart, is het voorwerp een soort van
speciaal geval van het oudervoorwerp. Bijvoorbeeld, als je 4 verschillende ballen hebt,
genoemd ball1, ball2, ball3 en ball4, die zich allen hetzelfde gedragen maar
verschillende sprite hebben, kunt je ball1 tot de ouder van andere drie maken. Nu moet
je slechts gebeurtenissen voor ball1 bepalen. Anderen zullen de gebeurtenissen erven
en zullen de zich op precies dezelfde manier gedragen. Dit bespaart heel wat werk.

Vaak, zullen de voorwerpen zich bijna hetzelfde moeten gedragen maar er kunnen
sommige kleine verschillen zijn. Bijvoorbeeld, één monster zal zich op en neer kunnen
bewegen en de andere van links naar rechts. Voor de rest hebben zij precies hetzelfde
gedrag. In dit geval bijna zouden alle gebeurtenissen dezelfde werking moeten hebben
maar één of twee zou verschillend kunnen zijn. Opnieuw kunnen wij één voorwerp tot de
ouder van andere maken. Maar in dit geval bepalen wij ook bepaalde gebeurtenissen
voor het kindvoorwerp. Deze gebeurtenissen negeren de oudergebeurtenissen.
Wanneer een gebeurtenis voor het kindvoorwerp acties bevat, worden deze uitgevoerd
in plaats van de gebeurtenis van de ouder. Als je de ook oudergebeurtenis wilt uitvoeren
kan je de zogenaamde "geërfde" gebeurtenis oproepen de aangewezen actie gebruiken.

De objecten van de ouder kunnen ouders opnieuw hebben, enz. (je mag geen cycli
creëren) Op deze wijze kunt je een objecthiërarchie creëren. Dit is uiterst nuttig om
gestructureerd spel te creëren en je wordt sterk geadviseerd om dit mechanisme te leren
gebruiken.

55
Er is ook een tweede gebruik van het ouderobject. Het erft ook het botsingsgedrag voor
andere objecten. Laat me dit met een voorbeeld verklaren. Veronderstel dat je vier
verschillende vloerobjecten hebt. Wanneer een bal de vloer raakt moet het van richting
veranderen. Dit moet in de botsingsgebeurtenis van de bal met de vloer worden
bepaald. Omdat er vier verschillende vloeren zijn moet ook de code inzake vier
verschillende botsingsgebeurtenissen van de bal gezet worden. Maar wanneer je één
vloer de ouder van andere drie maakt, moet je de slechts botsingsgebeurtenis met deze
één vloer bepalen. De andere botsingen zullen dezelfde gebeurtenis uitvoeren.
Opnieuw, redt dit heel wat het kopiëren.

16.4 Masks
Wanneer twee instanties in botsing komen komt er een botsingsgebeurtenis voor. Om te
besluiten of twee instanties snijden, worden sprites gebruikt. Dit is in de meeste gevallen
prettig, maar soms wilt je botsingen op een andere vorm baseren. Bijvoorbeeld, als je
een isometrisch spel maakt, hebben de objecten typisch een hoogte (om hen een 3D
uiterlijk te geven). Maar voor botsingen wilt je slechts het basisdeel van sprite gebruiken.
Dit kan worden bereikt door een afzonderlijke sprite te creëren die als botsingsmasker
voor het object wordt gebruikt.

56
Hoofdstuk 17 Meer over rooms
Ook heeft het scherm met de ruimtevorm een advanced tab. Hier zijn een aantal
geavanceerde aspecten van rooms beschikbaar.

Ten eerste, is er een checkbox Persistent. Normaal, wanneer je een room verlaat en er
later weer terug keert is de room weer terug in zijn begin toestand. Dit is prettig als je
een aantal niveaus in je spel hebt maar het is niet normaal in bijvoorbeeld een RPG.
Hier zou de room in de toestand moeten zijn zoals je hem de laatste keer verliet. Het
aanvinken van de box Persistent zal dat precies doen. De room toestand zal worden
onthouden en bij terugkeer zal de room er precies zo uitzien. Slechts wanneer je het
spel opnieuw begint zal de room teruggesteld worden. Eigenlijk, is er hier één
uitzondering op. Als je bepaalde objecten aanmerkte als blijvend (zie Error: Reference
source not found), zullen de instanties van dit object niet blijven in de room maar
meegaan naar de volgende ruimte.

Ten tweede, zijn er knoppen waarin je alle instanties in de room horizontaal of verticaal
kunt sorteren. Dit kan belangrijk zijn wanneer de instanties gedeeltelijk overlappen. De
volgorde bepaalt de tekeningenorde (tenzij je de diepte van de objecten veranderde).

Ook is er een knop Creation code. Hier kan je in een stuk van code in GML (zie hier
onder) typen die wordt uitgevoerd wanneer de room wordt gecreëerd. Dit is nuttig
bijvoorbeeld vul bepaalde variabelen voor de room in, creëer bepaalde instanties, enz.
Het is nuttig om te begrijpen wat gebeurt er precies wanneer je zich naar een bepaalde
room in het spel beweegt. Eerst worden de room en al zijn instanties geproduceerd
(wanneer de room niet blijvend is of niet voordien bezocht). Daarna, wanneer dit de
eerste room is, worden de gebeurtenissen van het beginspel uitgevoerd voor alle
instanties. Daarna (wanneer de room niet blijvend of niet voordien bezocht is) de code
van de ruimteverwezenlijking wordt uitgevoerd. Daarna worden de gebeurtenissen van
de beginroom uitgevoerd voor alle instanties. En tenslotte, voor de gecreëerde instanties
wordt de verwezenlijkinggebeurtenis uitgevoerd. Zo, bijvoorbeeld, kunnen de
verwezenlijkinggebeurtenissen variabelen gebruiken die door de verwezenlijkingcode
worden geplaatst voor de room en in de verwezenlijkingcode je naar de instanties in de
room kunt doorverwijzen.

Tenslotte, is er een knop Views.. Dit geeft een mechanisme om verschillende delen van
je room op verschillende plaatsen op het scherm te trekken. Ten eerste, in een
aantalspelen wilt je slechts een deel van de room op elk ogenblik tonen. Bijvoorbeeld, in
de meeste platformspelen, volgt de kijkrichting het belangrijkste figuur. In two-player
spelen wil je vaak scherm verdelen op wijze waarop in één deel van het scherm je één
speler ziet en in een ander deel zie je de andere speler. Een derde gebruik is in spelen
waarin een deel van de room zou moeten bewegen met het belangrijkste figuur terwijl
een ander deel wordt bevestigd (bijvoorbeeld één of ander status paneel). Dit kan
allemaal gemakkelijk in Game Maker gerealiseerd worden.

Wanneer je de knop Views klikt komt er een redelijk lege dialoog omhoog. Vink de
Enable the use of views aan en de volgende informatie zal verschijnen:

57
Aan de linkerkant zie je en lijst met de 8 plaatjes die je kunt definiëren. Aan de
rechterkant kun je de informatie opgeven voor deze beelden. Ten eerste moet je
aangeven of het plaatje zichtbaar moet zijn bij het betreden van de ruimte. Zorg er wel
voor dat er tenminste een plaatje zichtbaar is. Zichtbare plaatjes zijn vet weergegeven.
Vervolgens kun je aangeven welk gedeelte van de room zichtbaar moet zijn in het beeld.
Je geeft dat aan doormiddel van de positie van de linkerbovenkant en de breedte en
hoogte van het beeld. Daaronder kun je de plaats van het plaatje op het scherm
aangeven.

Zoals hierboven aangegeven wil je graag dat het plaatje een bepaald object kan volgen.
Dit object kun je onder aan het scherm opgeven. Wanneer er meerdere instanties zijn
van dit object wordt alleen de eerste gevolgd. Normaal zal het figuur zodanig bewegen
dat het plaatje niet hoeft te veranderen. Alleen wanneer het figuur in de buurt komt van
een beeldgrens, zal het plaatje veranderen. Je kunt de room opgeven die zichtbaar moet
blijven rondom het object. Tenslotte kun je de snelheid bepalen waarmee de plaatjes
veranderen. Dit betekent dat het figuur van het scherm kan lopen, maar het geeft een
veel gelijkmatiger beweging aan het spel. Gebruik –1 voor een snelle plaatje wisseling.

58
Hoofdstuk 18 Scripts
Game Maker heeft een ingebouwde programmeertaal. Zodra je vertrouwder wordt met
Game Maker en het optimaal wilt gebruiken, is het raadzaam om te beginnen met het
leren van deze taal. Voor een volledige beschrijving zie Hoofdstuk 23. Er zijn twee
manieren om de taal te gebruiken. Ten eerste kunnen je manuscripten creëren. Dit zijn
stukken code die je een naam geeft. Zij worden getoond in de resource tree en kunnen
behalve opgeslagen worden in een bestand ook geladen worden uit een bestand. Zij
kunnen worden gebruikt om een bibliotheek te vormen die de mogelijkheden van Game
Maker uitbreidt. Alternatief, kunt je een codeactie toevoegen aan één of andere
gebeurtenis en een stuk van code daar typen. Het toevoegen van codeacties werkt op
de precies zelfde manier zoals toevoegend manuscripten behalve twee verschillen. De
acties van de code hebben geen naam en kunnen geen argumenten gebruiken. Voor de
rest voert je precies code in op dezelfde manier zoals bij manuscripten. Zo concentreren
wij ons verder op manuscripten in dit hoofdstuk.

Zoals voordien verklaard, is een manuscript een stuk van code in de ingebouwde
programmeertaal die een bepaalde taak uitvoert. Een manuscript kan een aantal
argumenten nemen. Om een script van binnen één of andere gebeurtenis uit te voeren,
kan je de scriptactie gebruiken. In deze actie bepaal je het script dat je wilt uitvoeren,
samen met de tot drie argumenten. (Je kunt manuscripten van binnen een stuk van code
op dezelfde manier ook uitvoeren als je een functie aanroept. In dat geval kan je tot 10
argumenten gebruiken.) Wanneer het script een waarde teruggeeft, kan je het als functie
ook gebruiken voor het verstrekken van waarden in andere acties.

Om een manuscript aan je spel toe te voegen, kies Add Script van het Add menu. Het
volgende scherm komt omhoog (in het voorbeeld hebben wij reeds een script
toegevoegd dat gegevens produceert vanuit twee argumenten).

59
Rechtsboven kan je op de naam van het manuscript wijzen. Je heeft een kleine tekst
editor waarin je een stukje script kunt typen. Er zijn een paar knoppen voor cut-and-
paste en voor opslaan en inlezen van het script als tekstbestand. Ook is er een knop
waarmee je kunt testen of het script correct is. Niet alle aspecten kunnen in dit stadium
worden getest maar de syntaxis van je manuscript zal, samen met het bestaan van
gebruikte functies worden getest.

Zoals je opgemerkt zult hebben, zijn de delen van de manuscripttekst gekleurd. De

editor is van bestaande objecten, ingebouwde variabelen en functies, enz. op de hoogte
Kleurcodering is een hulp bij het vermijden van fouten. In het bijzonder, ziet je
onmiddellijk of je schreef één of andere naam verkeerd of gebruikt een sleutelwoord als
variabele. De kleurcodering is echter wel langzaam. In de voorkeur in het dossiermenu
kunt je kleurcodering aan en uitschakelen. Hier kan je de kleur voor de verschillende
componenten van de programma's ook ruilen. Ook kan je font veranderen die in
manuscripten en code wordt gebruikt.

De manuscripten zijn uiterst nuttig om de mogelijkheden van Game Maker uit te breiden.
Dit vereist niettemin dat je je scripten zorgvuldige ontwerpt. De scripten kunnen in
bibliotheken worden opgeslagen die aan je spel kunnen worden toegevoegd. Om een
bibliotheek in te voeren, gebruik je Import scripts uit het bestandsmenu. Om je scripten
in de vorm van scripten op te slaan gebruikt je Export scripts. De bibliotheken met
scripten zijn eenvoudige tekstbestanden (hoewel zij de extensie hebben van .gml). Bij
voorkeur niet direct editen omdat zij een speciale structuur hebben. Sommige
bibliotheken met nuttige manuscripten zijn inbegrepen. (Om onnodige werk te vermijden
bij het laden van het spel, na het invoeren van een bibliotheek, kun je het beste scripts
schrappen die je niet gebruikt.)

Bij het creëren van manuscripten maakt je gemakkelijk fouten. Test altijd de scripten
door de aangewezen knop te gebruiken. Wanneer een fout tijdens de uitvoering van een
script voorkomt wordt dit gemeld, met een aanwijzing van het type van fout en de plaats.
Als je dingen zorgvuldig wilt controleren, kan je het spel in werking stellen in debug
mode. Nu verschijnt een scherm waarin je bepaalde informatie in je spel kunt
controleren. Gebruikend maken van de Add knop kunt je een variabele invoeren
waarvan waarde in elke stap van het spel wordt getoond. Op deze wijze kan je zien of je
spel dingen op de juiste manier doet. Ook kan je pauzeren, je spel stap door stap
uitvoeren, en het opnieuw beginnen. Verder, wordt een aanwijzing van de snelheid in
frames per seconde gegeven.

60
Hoofdstuk 19 Spel informatie
Een goed spel voorziet de speler van wat informatie over hoe het spel te spelen. Deze
informatie wordt getoond wanneer de speler de< F1 > toets indrukt tijdens het spel. Om
de spelinformatie te creëren, dubbelklik op Game Information in de resource tree aan
de linkerkant van het scherm. Een kleine teksteditor wordt geopend waar je de
spelinformatie kunt intypen. Je kunt verschillende fonts, verschillende kleuren, en stijlen
gebruiken. Een goede raad maak de informatie kort maar nauwkeurig. Natuurlijk zou je
je naam moeten toevoegen omdat je het spel creëerde. Alle verstrekte voorbeeldspelen
hebben een informatie dossier over het spel en hoe het werd gecreëerd.

Als je een beetje meer buitensporige hulp wilt aanmaken, gebruik dan bijvoorbeeld
Word. En selecteer dan het deel en knip en plak je tekst in de editor van Game Maker.

61
Hoofdstuk 20 Spel opties
Er zijn een aantal opties die je kan veranderen voor je spel. Deze zijn te vinden door te
dubbelklikken op Game Options in de boomstructuur aan de linkerkant van het scherm.
Deze opties zijn onderverdeeld in een aantal tabbladen.

20.1 Graphics opties

Start in full screen mode

Als deze optie aangevinkt is werkt het scherm in een volledig scherm, anders in een
window.

Scale the image in full screen mode

Als deze optie aangevinkt is zal het plaatje zoveel mogelijk uitgevuld worden over het
hele scherm. Anders wordt het gecentreerd. Uitvullen is langzamer, maar de meeste
moderne grafische kaarten moeten dit wel aankunnen. Maar zorg ervoor dat het window
niet groter is dan het beeldscherm, want verkleinen tot beeldscherm formaat is normaal
gesproken erg traag.

Use exclusive graphics mode

In exclusive mode maakt het spel volledig gebruikt van het scherm. Geen enkele andere
applicatie kan nog van het scherm gebruik maken. Daardoor kun je de resolutie en
daarna de kleurdiepte instellen. Het maakt de plaatjes meestal wat sneller. Als je zeker
wilt weten dat de speler de juiste schermresolutie heeft kun je het best deze mode
gebruiken. Toch moet hier wel een waarschuwing geplaatst worden. In de exclusive
mode kun je geen enkel ander window zien. Dit betekent bijvoorbeeld dat je geen acties
kunt gebruiken die een boodschap weergeven, een vraag stellen, de highscore lijst of
spelinformatie laten zien. Ook kunnen er geen fouten worden gerapporteerd. In het
algemeen geldt dus: als er iets fout gaat in exclusive mode heeft de speler geen andere
keus dan de computer opnieuw op te starten. Dus zorg ervoor dat je spel absoluut
correct werkt. Je kan je spel niet in de debug mode laten lopen als je de exclusive mode
gebruikt.

Wait for vertical blank before drawing

Het scherm van je computer wordt een aantal keer per seconde ververst (normaal
gesproken tussen de 50 en de 100 keer). Na het verversen van het scherm volgt een
zogenaamd ‘vertical blank’ waarin er niks op het scherm plaatsvindt. Als je het scherm
continu teken, kan het voorkomen dat een gedeelte van een plaatje en een deel van het
volgende plaatje tegelijk op het scherm staan. Dit ziet er niet erg professioneel uit. Als je
wacht op het ‘vertical blank’ voordat het volgende frame getekend wordt, verdwijnt dit
probleem. Het nadeel is dat het programma moet wachten op het ‘vertical blank’
hetgeen voor een kleine vertraging kan zorgen.

Display the cursor

Deze optie geeft aan of je de mousepointer zichtbaar wilt hebben of niet. Het is normaal
gesproken sneller en mooier om deze optie uit te zetten. (Je kan heel gemakkelijk je
eigen cursorobject in Game Maker maken.)

62
Display the caption in full screen mode
Als deze optie aangevinkt is zal er in fullscreen mode een klein wit vierkantje getekend
worden in de linker bovenhoek. Hierin wordt de schermtitel, de score en het aantal
levens aangegeven. Het is normaal gesproken mooier als je deze dingen zelf tekent op
een geschikte plaats in je wereld.

20.2 Key opties

Let <Esc> end the game

Als deze optie aangevinkt is zal het intoetsen van de escapeknop het spel beëindigen.
Meer geavanceerde spellen willen dit normaal gesproken niet omdat ze nog processen
(zoals opslaan) willen doorlopen voordat het spel afloopt. Vink in dit geval deze optie
niet aan en zorg voor je eigen acties voor de escapeknop. (Klikken op het kruisje van het
window zal ook een escapeknop-event genereren.)

Let <F1> show the game information

Als deze optie is aangevinkt en je drukt op de F1-toets dan wordt de spelinformatie
weergeven (niet in exlusive mode).

Let <F4> switch between screen modes

Als deze optie is aangevinkt dan kun je met de F4-toets wisselen tussen fullscreen en
windowed mode (niet in exlusive mode).

Let <F5> and <F6> load and save the game

Als deze optie is aangevinkt kan de speler zijn spel opslaan door op de F5-toets te
drukken en een opgeslagen spel openen door op de F6-toets te drukken.

20.3 Interaction opties

Generate continuous keyboard events

Als deze optie is aangevinkt, wordt een keyboard-event uitgevoerd zolang een toets
ingedrukt blijft. Als deze optie uitstaat wordt het keyboard-event alleen uitgevoerd op het
moment dat de toets ingedrukt wordt. Voor verschillende soorten spellen heb je hier
verschillende instellingen nodig.

Generate continuous mouse events

Als deze optie is aangevinkt wordt een muis-event uitgevoerd zolang de muisknop
ingedrukt blijft. Als deze optie uitstaat wordt het event alleen uitgevoerd op het moment
dat de knop ingedrukt wordt.

Freeze the game when the form looses focus

Als deze optie is aangevinkt en een speler maakt een ander venster actief dan bevriest
het spel totdat het spel weer het actieve venster wordt.

63
20.4 Score opties

Show the score

Als deze optie is aangevinkt wordt de score in beeld weergeven. Ook het aantal levens
wordt weergegeven

De ander opties hebben te maken met het uiterlijk van de highscore lijst. Om te
beginnen kun je de highscore lijst een achtergrondplaatje geven (bij voorkeur met
afmeting 360x400, anders wordt het automatisch aangepast). In plaats daarvan kun je
ook een achtergrondkleur aangeven. Verder kun je nog de tekstkleur instellen en de
kleur die gebruikt wordt voor het aangeven van een nieuwe hoogste score. Je kunt ook
het lettertype veranderen. Als laatste kun je aangeven of de lijst een rand of een titel
moet hebben of niet. Het gebruik van de juiste instellingen zal leiden tot een
aantrekkelijke highscore lijst.

20.5 Loading opties

Hier kun je aangeven wat er moet gebeuren als een spel geladen wordt. Ten eerste kun
aangeven welk plaatje in beeld moet zijn tijdens het laden.

Ten tweede kun je aangeven of er een voortgangsbalk onderaan het plaatje moet staan
of niet. Je hebt hier drie opties. Of er wordt geen balk weergegeven of er wordt een
standaardbalk weergegeven of je kan twee plaatjes aangeven: de achtergrond van de
voortgangsbalk en de voorgrond. Die plaatjes zullen passend gemaakt worden. (Merk op
dat beide plaatjes aangeven moeten worden, niet slechts één.)

Op de derde plaats kun je het icoontje kiezen dat gebruikt moet worden voor stand-
alone spellen. Je kunt alleen 32x32 icoontjes met 16 kleuren gebruiken. Als je een ander
type icoontje wilt kiezen krijg je een waarschuwing.

Als laatste kun je het unieke id-nummer van het spel veranderen. Dit id-nummer wordt
gebruikt voor het opslaan van highscore lijsten en spelbestanden. Als je een nieuwe
versie van je spel uitbrengt en niet de oude highscore lijsten wilt overnemen, zou je dit
nummer moeten veranderen.

64
Hoofdstuk 21 Snelheidsoverwegingen
Als je ingewikkelde spellen maakt wil je vast en zeker dat ze zo snel mogelijk werken.
Hoewel Game Maker er alles aan doet om de spellen zo snel mogelijk te maken hangt
er veel af van de manier van ontwerpen. Het is helemaal niet moeilijk om een spel te
maken dat enorme hoeveelheden geheugen gebruikt. In dit hoofdstuk zal ik wat hints
geven voor het maken van snellere en kleinere spellen.

Wees ten eerste voorzichtig met het gebruik van sprites (spelattributen) en
achtergronden. Bewegende sprites gebruiken veel geheugen en het tekenen van veel
sprites kost veel tijd met inladen. Dus maak je sprites zo klein mogelijk. Verwijder alle
onzichtbare ruimte rond de sprite (daar is een commando voor in de sprite-editor).
Bedenk erg goed welke sprites je wilt laden in het videogeheugen en welke pas geladen
moeten worden bij gebruik. Dit zelfde geldt ook voor de achtergronden. In het algemeen
wil je ze pas laden bij het gebruik en in het bijzonder, wanneer ze veel geheugenruimte
innemen, wil je ze niet opslaan in het videogeheugen. Zorg ervoor dat je het gebruik van
een achtergrondkleur uitzet wanneer je een achtergrond hebt die het hele scherm
bedekt.

Wanneer je gebruik maakt van fullscreen mode of exclusive mode wees er dan zeker
van dat de grootte van je wereld (of window) nooit groter is dan het scherm. De meeste
videokaarten kunnen plaatjes makkelijker uitschalen naar een groter formaat dan
andersom! Dus probeer zo min mogelijk andere dingen te tekenen dan sprites want daar
wordt je spel trager van. Als je deze dingen toch nodig hebt zorg er dan voor dat deze
snel achter elkaar getekend worden. En als laatste moet je ervoor zorgen dat, wanneer
het mogelijk is, de cursor uitgeschakeld wordt omdat deze de plaatjes vertraagt.

Maar wees voorzichtig met het gebruik van veel views. Voor elke view wordt het veld
opnieuw getekend.

Naast de plaatjes zijn er nog andere aspecten die de snelheid beïnvloeden. Wees er
zeker van dat je zo weinig mogelijk instanties geladen hebt. In het algemeen moet je
instanties die niet meer nodig zijn verwijderen (bijv. wanneer ze jou wereld verlaten).
Vermijd veel werk in het step event of het teken event van instanties. Vaak hoeven
dingen niet in elke stap gechecked te worden. Vertaling van code is best snel, maar het
moet wel vertaald worden. Ook kosten sommige functies en acties veel tijd, speciaal
diegenen die alle instanties moeten checken (zoals bijvoorbeeld de stuiter actie).

Denk erover na waar je de botsing events wilt behandelen. Normaal gesproken heb je
twee opties. Objecten die helemaal geen botsing event hebben worden veel sneller
behandeld, dus behandel ze bij voorkeur in die objecten die slechts een paar instanties
hebben.

Wees voorzichtig bij gebruik van grote soundfiles. Deze nemen veel geheugenruimte in
beslag en na compressie zijn deze bestanden niet erg verkleind. Misschien kun je eens
bekijken of je je geluiden door middel van sampling kleiner kunt maken.

Tenslotte, wanneer je een spel wilt maken dat door veel mensen gespeeld kan worden,
test deze dan op kleine machines.

65
Hoofdstuk 22 Je spel verspreiden
Als je eenmaal een leuk spel hebt gemaakt, wil je het waarschijnlijk aan andere mensen
geven om het te spelen. Je bent vrij om je spel op alle manieren te verspreiden. Je kan
ze zelfs verkopen. Zie voor meer informatie de ingesloten licentie overeenkomst.

Er zijn in principe drie verschillende manieren waarop je je spellen kunt verspreiden. De

makkelijkste manier is mensen simpelweg het *.gmd bestand te geven waarin het spel
staat. Dit betekent dat die persoon Game Maker moet hebben. (Het is niet toegestaan
om Game Maker met je spel te verspreiden, maar men kan het gratis downloaden van
de site.) Ook kan de andere persoon het spel veranderen.

De tweede manier is het maken van een stand-alone versie van het spel. Een stand-
alone versie is simpelweg één executable. Dit kan bereikt worden door het kiezen van
het item Create stand-alone in het File menu. Je wordt gevraagd naar de naam van het
executable dat het spel gaat bevatten. Geef een naam aan, klik OK en je hebt een
stand-alone spel dat je aan elke gewenste persoon kan geven. Je kan het icoon voor het
stand-alone spel instellen in het Options formulier. (Als je spel andere bestanden
gebruikt moet je die kopiëren in de map waarin de stand-alone staat.) Nu moet je dit
bestand aan andere mensen geven (Misschien moet je het eerst zippen.)

De derde manier is het maken van een installer. Een aantal freeware installer
programma’s zijn beschikbaar op het web. Je maakt weer een stand-alone versie en dan
gebruik je de installer om een installatie te maken. Hoe dit werkt hangt af van de installer
die je gebruikt.

Als je een geweldig spel hebt gemaakt, mail dit alsjeblieft naar gamemaker@wanadoo.nl
zodat ik het op het web kan zetten. Stuur alsjeblieft geen install programma’s, alleen
.gmd files of stand-alone versies.

66
Hoofdstuk 23 De Game Maker Language (GML)
Zoals je eerder hebt gelezen, bevat Game Maker een ingebouwde programmeertaal.
Deze programmeertaal geeft je veel meer flexibiliteit en controle dan de standaard
acties. Deze taal zullen we aanduiden met GML (de Game Maker Language). Er zijn
drie verschillende plaatsen waar je programma’s in deze taal kunt typen. Ten eerste als
je scripts definieert. Een script is een programma in GML. Ten tweede als je een code
actie toevoegt aan een event. In een code actie moet je weer zorgen voor een
programma in GML. Als laatste, overal waar je een waarde in een actie moet
specificeren, kun je ook een expressie in GML gebruiken. Een expressie is, zoals we
hieronder zullen zien, niet een compleet programma, maar een deel dat als resultaat
een waarde heeft.

In dit hoofdstuk zal ik de basisstructuur van programma’s in GML beschrijven. Wanneer

je programma’s in GML wilt gebruiken zijn er een paar dingen waar je voorzichtig mee
moet zijn. Ten eerste, voor al je elementen (sprites, objecten, geluiden, etc.) moet je
namen gebruiken die met een letter beginnen en alleen bestaan uit letters, cijfers en het
underscore ‘_’ symbool. Anders kun je ze niet oproepen vanuit het programma. Kijk ook
uit dat je elementen niet self, other, global of all noemt omdat deze woorden een
speciale betekenis hebben in de taal. Ook moet je niet een van de sleutelwoorden
gebruiken die hieronder zijn aangegeven.

23.1 Een programma

Een programma bestaat uit een blok. Een blok bestaat uit een of meer statements,
ingesloten door de tekens ‘{‘ en ‘}’. Statements moeten gescheiden worden door een ‘;’
symbool. Dus de globale structuur van elk programma is:

{
<statement>;
<statement>;
…
}

Een statement kan ook weer een blok van statements zijn. Er zijn een aantal
verschillende types statements, die hieronder besproken worden.

23.2 Variabelen
Zoals elke programmeertaal bevat GML variabelen. Variabelen kunnen reële waarden of
strings bevatten. Variabelen hoeven niet gedeclareerd te worden. Er is een groot aantal
ingebouwde variabelen. Sommige zijn algemeen, zoals mouse_x en mouse_y die de
huidige positie van de muis aangeven, terwijl alle andere lokaal zijn voor de object
instantie waarvoor we het programma uitvoeren, zoals x en y die de huidige positie van
de instantie aangeven. Een variabele heeft een naam die moet beginnen met een letter
en die alleen letters, getallen en het underscore symbool ‘_’ bevat. (De maximale lengte
is 64 symbolen.) Als je een nieuwe variabele gebruikt is die lokaal voor de huidige
instantie en is niet bekend in programma’s voor andere instanties (zelfs van hetzelfde
object). Je kunt echter naar variabelen verwijzen in andere instanties; zie hieronder.

67
23.3 Toewijzingen
Een toewijzing wijst de waarde van een expressie toe aan een variabele. Een toewijzing
heeft de vorm:

<variable> = <expression>;

In plaats van een waarde aan een variabele toekennen kan men de waarde er ook bij
optellen met +=, aftrekken met -=, vermenigvuldigen met *= of delen met /=. (Dit werkt
alleen voor reële waarde variabelen en expressies, niet voor strings.)

23.4 Expressies
Expressies kunnen reële waarden zijn (bijv. 3,4), strings tussen enkele en dubbele
aanhalingstekens (bijv. ‘hallo’ of “hallo”) of meer ingewikkelde expressies. Voor
expressies bestaan de volgende binaire operatoren (in volgorde van belangrijkheid.):

 &&, ||: Combineren van true/false waarden (&& betekent en, || betekent of)
 <, <=, ==, !=, >, >=: vergelijkingen, resulterend in waar (true, 1) of onwaar (false,
0)
 +, -: optelling, aftrekking
 *, /, div, mod: vermenigvuldiging, deling, deling van gehele getallen, en modulo

Ook bestaan de volgende unaire operatoren:

 !: niet, veranderd waar in onwaar en onwaar in waar.

 -: neemt het tegengestelde van de volgende waarde.

Als waarden kun je getallen, variabelen of functies die een waarde geven gebruiken.
Subexpressies kunnen tussen haakjes geplaatst worden. Alle operatoren werken voor
reële waarden. Vergelijkingen werken ook voor strings en + plakt strings aan elkaar.

Voorbeeld
Hier is een voorbeeld met wat toewijzingen:

{
x = 23;
str = 'hallo wereld';
y += 5;
x *= y;
x = 23*((2+4) / sin(y));
str = 'hallo' + " wereld";
b = (x < 5) && !(x==2 || x==4);
}

23.5 Extra variabelen

Je maakt nieuwe variabelen door er een waarde aan toe te kennen (je hoeft ze niet eerst
te declareren). Als je gewoonweg een variabelennaam gebruikt, wordt de variabele
alleen voor de huidige object instantie opgeslagen. Dus verwacht niet dat je het later zult
vinden als je met een ander object bezig bent (of een andere instantie van hetzelfde

68
object). Je kan ook variabelen instellen en lezen in andere objecten door de objectnaam
met een punt voor de variabelennaam te plaatsen.

Om een globale variabele, die te zien zijn voor alle object instanties, te maken, laat je de
naam vooraf gaan door global en een punt. Dus je kunt bijvoorbeeld schrijven:

{
if (global.doit)
{
// doe iets
global.doit = false;
}
}

23.6 Variabelen aanroepen in andere instanties

Zoals beschreven kun je variabelen instellen in de huidige instantie door gebruik te
maken van statements als

x = 3;

Maar in een aantal gevallen wil je de variabelen aanroepen in een andere instantie.
Bijvoorbeeld: misschien wil je de beweging van alle ballen stoppen of je wilt de
hoofdpersoon naar een specifieke positie bewegen, of, in het geval van een botsing, je
wilt de sprite instellen voor de andere instantie die betrokken is. Dit kan bereikt worden
door de variabelennaam vooraf te laten gaan door de naam van een object en een punt.
Dus je kunt bijvoorbeeld schrijven

bal.speed = 0;

Dit zal de snelheid van alle instanties van het object bal veranderen. Er is een aantal
speciale “objecten”.
 self: De huidige instantie waarvoor we de actie uitvoeren.
 other: De andere instantie die betrokken is bij een botsing-event
 all: Alle instanties
 noone: Geen enkele instantie (Dit lijkt misschien raar, maar het blijkt handig te
zijn zoals we later zullen zien)
 global: Geen enkele instantie, maar een container die globale variabelen
opslaat
Je kunt dus bijvoorbeeld de volgende statement gebruiken:

other.sprite_index = sprite5;
all.speed = 0;
global.message = 'Een goed resultaat';
global.x = ball.x;

Nu vraag je je misschien af wat de laatste toewijzing doet als er meerdere ballen zijn.
Nou, hij neemt de eerste en de x-waarde daarvan wordt toegekend aan de globale
waarde.

Maar wat als je de snelheid van een specifieke bal wilt instellen, in plaats van alle
ballen? Dit is iets ingewikkelder. Elke instantie heeft een unieke id. Als je instanties in

69
een kamer in de ontwerper stopt, zie je de id als de muis op die instantie rust.Dit zijn
nummers groter of gelijk aan 100000. Zo’n nummer kun je ook links van een punt
schrijven. Maar kijk uit. De punt zal geïnterpreteerd worden als een decimale punt. Om
dit te voorkomen, zet je haakjes om het getal. Aangenomen dat de id van de bal 100032
is, kun je dus bijvoorbeeld schrijven:

(100032).snelheid = 0;

Als je een instantie in het programma maakt, geeft de aanroep de id. Dus een geldig
stuk programma is

{
nnn = instance_create(100,100,ball);
nnn.speed = 8;
}

Dit maakt een bal en stelt zijn snelheid in. Merk op dat we de instantie id toewijzen aan
een variabele en dat we die variabele gebruiken als indicatie voor de punt. Dit is
volkomen geldig. Laat me proberen dit nog wat preciezer te maken. Een punt is eigenlijk
een operator. Het neemt de waarde als linker operand en een variabele (adres) als
rechter operand, en het geeft het adres van deze specifieke variabele in het aangegeven
object of instantie. Alle objectnamen, en de speciale objecten die hierboven staan
representeren simpelweg waarden en daar kan mee gewerkt worden als met een
waarde. Bijvoorbeeld, het volgende programma is geldig:

{
obj[0] = ball;
obj[1] = flag;
obj[0].alarm[4] = 12;
obj[1].id.x = 12;
}

De laatste statement moet als volgt gelezen worden. We nemen de id van de eerste
vlag. Met die id zetten we bijvoorbeeld de x-coördinaat op 12.

Objectnamen, de speciale objecten en de instantie-id’s kunnen ook in een aantal

functies gebruikt worden.

23.7 Arrays
Je kunt 1- en 2-dimensionale arrays gebruiken in GML. Zet simpelweg de index tussen
vierkante haken bij een 1-dimensionale array en de twee indices met een komma
ertussen bij 2-dimensionale arrays. Op het moment dat je een index gebruikt wordt de
array gegenereerd. Elke array loopt vanaf index 0. Dus let op bij het gebruik van grote
indices, omdat geheugen voor een grote array wordt gereserveerd. Gebruik nooit
negatieve indices. Het systeem heeft een limiet van 32000 op elke index en 1000000 op
de totale grootte. Dus je kunt bijvoorbeeld het volgende schrijven.

{
a[0] = 1;
i = 1;
while (i < 10) { a[i] = 2*a[i-1]; i += 1;}
b[4,6] = 32;

70
 }

23.8 If statement
Een if statement heeft de volgende vorm

if (<expression>) <statement>
of
if (<expression>) <statement> else <statement>

De statement kan ook een blok zijn. De expressie wordt geëvalueerd. Als de (afgeronde)
waarde > 0 (true) is wordt de statement voor else uitgevoerd, anders (false) wordt de
andere statement uitgevoerd. Het is een goede gewoonte om altijd accolades om de
statement in de if-statement te plaatsen. Dus gebruik het liefst

if (<expression>)
{
<statement>
}
else
{
<statement>
}

Voorbeeld
Het volgende programma beweegt het object naar het midden van het scherm.

{
if (x<200) {x += 4} else {x -= 4};
}

23.9 Repeat statement

Een herhaal (repeat) statement heeft de vorm

repeat (<expression>) <statement>

De statement wordt herhaald zo vaak als de afgeronde waarde van expressie aangeeft.

Voorbeeld
Het volgende programma maakt vijf ballen op willekeurige posities.

{
repeat (5) instance_create(random(400),random(400),ball);
}

23.10 While statement

Een terwijl (while) statement heeft de vorm

while (<expression>) <statement>

71
Zolang de expressie waar is, wordt de statement (dat ook een blok kan zijn) uitgevoerd.
Wees voorzichtig met je while-loops. Je kan ze makkelijk voor eeuwig laten rondlopen,
en dan blijft je spel hangen en zal niet meer reageren op enige input van de gebruiker.

Voorbeeld
Het volgende programma probeert het huidige object op een vrije positie te plaatsen (dit
is ongeveer dezelfde als de actie die een object op een willekeurige plaats neerzet).

{
while (!place_free(x,y))
{
x = random(room_width);
y = random(room_height);
}
}

23.11 For statement

Een voor (for) statement heeft de vorm

for (<statement1> ; <expression> ; <statement2>) <statement3>

Dit werkt als volgt. Eerst wordt statement 1 uitgevoerd. Dan wordt de expressie
geëvalueerd. Als deze waar is wordt statement 3 uitgevoerd en dan wordt de expressie
weer geëvalueerd. Dit gaat zo door totdat de expressie onwaar is.

Dit klinkt misschien ingewikkeld. Je moet het als volgt interpreteren. De eerste statement
initialiseert de for-loop. De expressie test of de loop beëindigd moet worden. Statement
2 is het stap statement dat naar de volgende loop evaluatie leidt.

Het meest voorkomende geval is dat een teller een interval doorloopt.

Voorbeeld
De volgende statement initialiseert een array van lengte 10 met de waarden 1-10.

{
for (i=0; i<9; i+=1) list[i] = i+1;
}

23.12 Exit statement

Het einde (exit) statement heft de volgende vorm

exit

Het beëindigt simpelweg de uitvoering van dit programma. (Het beëindigt niet de
uitvoering van het spel! Hiervoor heb je de functie game_end() nodig; zie hieronder.)

23.13 Functie
Een functie heeft de vorm van een functienaam gevolgd door nul of meer argumenten
tussen haakjes, gescheiden door komma’s.

<function>(<arg1>,<arg2>,…)

72
Er zijn twee soorten functies. Ten eerste is er een enorme collectie ingebouwde functies
om alle aspecten van het spel te besturen. Ten tweede kan elk script dat je in je spel
definieert gebruikt worden als functie.

Merk op dat je bij een functie zonder argumenten nog steeds de haakjes moet
gebruiken. Sommige functies geven waarden terug en kunnen in expressies gebruikt
worden. Andere voeren simpelweg commando’s uit.

23.14 Scripts
Als je een script maakt wil je toegang tot de argumenten die erbij horen (als je de script
actie gebruikt of als je het script als een functie oproept in een programma (of vanuit een
ander, of zelfs het huidige, script)). Deze argumenten worden opgeslagen in de
variabelen argument0, argument1, …, argument9. Dus er kunnen maximaal 10
argumenten zijn. (Merk op dat wanneer je een script vanuit een actie oproept alleen de
eerste drie argumenten kunnen worden gespecificeerd.)

Script kunnen ook een waarde teruggeven, zodat ze gebruikt kunnen worden in
expressies. Voor dit geval gebruik je de return statement.

return <expression>

Uitvoering van het script eindigt bij het return statement.

Voorbeeld

Hier is de definitie van een klein script dat het kwadraat van het argument berekend:

{
return (argument0*argument0);
}

Om een script op te roepen binnen een stuk code doe je hetzelfde als wanneer je een
functie oproept. Dus, schrijf de naam van het script met de waarden van de argumenten
tussen ronde haakjes.

23.15 With constructies

Zoals al eerder aangegeven is, is het mogelijk om de waarde van variabelen te lezen en
te veranderen in andere instanties. Maar in een aantal gevallen wil je veel meer doen
met andere instanties. Bijvoorbeeld, stel je voor dat je alle ballen 8 pixels naar beneden
wilt bewegen. Misschien denk je dat je dat met het volgende stukje code voor elkaar
krijgt:

ball.y = ball.y + 8;

Maar dat is niet waar. De rechterkant van de toekenning pakt de waarde van de y-
coördinaat van de eerste bal en telt er 8 bij op. Vervolgens wordt deze waarde ingesteld
als y-coördinaat voor alle ballen. Dus het resultaat is dat alle ballen dezelfde y-
coördinaat krijgen. Het statement

73
 ball.y += 8;

zal precies hetzelfde effect hebben omdat het simpelweg een afkorting is van de eerste
statement. Dus hoe krijgen we dit voor elkaar? Voor dit doel bestaat de with statement.
Zijn globale vorm is

with (<expression>) <statement>

<expression> geeft een of meer instanties aan. Hiervoor kun je een instantie id
gebruiken, de naam van een object (om alle instanties van dat object aan te geven) of
een van de speciale objecten (all, self, other of noone). <statement> wordt nu
uitgevoerd voor elk van de aangegeven instanties, alsof die instantie de huidige instantie
(self) is. Dus, om alle ballen 8 pixels naar beneden te verplaatsen kun je typen

with (ball) y += 8;

Als je meervoudige statements wilt uitvoeren zet je accolades erom heen. Dus om
bijvoorbeeld alle ballen naar een willekeurige plaats te verplaatsen, kun je gebruiken

with (ball)
{
x = random(room_width);
y = random(room_height);
}

Merk op dat, binnen de statement(s), de aangegeven instantie de self instantie is

geworden. Binnen de statements is de werkelijke self instantie de andere instantie
geworden. Dus om bijvoorbeeld alle ballen naar de positie van de huidige instantie te
verplaatsen, kun je typen

with (ball)
{
x = other.x;
y = other.y;
}

Het gebruik van de with statement is ontzettend sterk. Laat ik nog een paar voorbeelden
geven. Om alle ballen te vernietigen type je

with (ball) instance_destroy();

Als een bom explodeert en je wilt alle instanties in de buurt vernietigen kun je gebruiken:

with (all)
{
if (distance_to_object(other) < 50) instance_destroy();
}

23.16 Commentaar
Je kunt commentaar toevoegen aan je programma’s. Alles op een regel na // wordt niet
gelezen. Het wordt intern gebruikt om het einde van een regel aan te geven.

74
23.17 Pascal stijl
De vertaler is eigenlijk behoorlijk soepel. Je kunt ook programma’s gebruiken die veel op
Pascal lijken. Je kunt ‘begin’ en ‘end’ gebruiken om blokken te begrenzen, := gebruiken
om toe te kennen en zelfs het woord ‘then’ gebruiken in een if statement of ‘do’ in een
while loop. Bijvoorbeeld, het volgende programma is geldig:

begin
x := 10;
while x>0 do
begin
if x=5 then x:=x-5 else x:=x-1;
end;
end;

23.18 Functies en variabelen in GML

GML bevat een groot aantal ingebouwde functies en variabelen. Hiermee kun je elk deel
van het spel beheersen. Voor alle acties zijn er corresponderende functies dus je hoeft
eigenlijk geen acties te gebruiken als je liever code gebruikt. Maar er zijn veel meer
functies en variabelen die aspecten van het spel bepalen die niet gebruikt kunnen
worden met alleen maar acties. Dus als je geavanceerde spellen wilt maken raad ik je
sterk aan de volgende hoofdstukken door te lezen om een idee te krijgen van wat
allemaal mogelijk is. Merk alsjeblieft op dat deze variabelen en functies ook gebruikt
kunnen worden als je waarden voor acties aangeeft. Dus zelfs als je niet van plan bent
code te gebruiken of scripts te schrijven zul je profijt hebben van deze informatie.

De volgende conventie wordt hieronder gebruikt. Variabelenamen gemarkeerd met * zijn

read-only, dat wil zeggen dat hun waarde niet veranderd kan worden. Variabelenamen
met [0..n] erachter zijn arrays. Het bereik van mogelijke indices is gegeven.

75
Hoofdstuk 24 Dingen berekenen
Game Maker bevat een groot aantal functies om bepaalde dingen te berekenen. Hier is
een complete lijst.

24.1 Constanten
De volgende constanten bestaan:

true Gelijk aan 1.

false Gelijk aan 0.
pi Gelijk aan 3.1415…

24.2 Reële waarde functies

De volgende functies die met reële getallen werken bestaan:

random(x) Geeft een willekeurig reëel getal tussen 0 en x. Het getal is altijd
kleiner dan x.
abs(x) Geeft de absolute waarde van x.
sign(x) Geeft het teken van x (1 of –1).
round(x) Rond x af op gehelen.
floor(x) Geeft de entier van x, dat wil zeggen, x afgerond op een geheel getal
naar beneden.
ceil(x) Geeft de bovenentier van x, dat wil zeggen, x afgerond op een geheel
getal naar boven.
frac(x) Geeft het gebroken deel van x, dat wil zeggen, het deel achter de
komma.
sqrt(x) Geeft de wortel van x, x mag niet negatief zijn.
sqr(x) Geeft x*x.
power(x,n) Geeft x tot de macht n.
exp(x) Geeft e tot de macht x.
ln(x) Geeft de natuurlijke logaritme van x.
log2(x) Geeft de 2-log van x.
log10(x) Geeft de 10-log van x.
logn(n,x) Geeft de n-log van x.
sin(x) Geeft de sinus van x (x in radialen).
cos(x) Geeft de cosinus van x (x in radialen).
tan(x) Geeft de tangens van x (x in radialen).
arcsin(x) Geeft de inverse sinus van x.
arccos(x) Geeft de inverse cosinus van x.
arctan(x) Geeft de inverse tangens van x.
degtorad(x) Zet graden om in radialen.
radtodeg(x) Zet radialen om in graden.
min(x,y) Geeft het minimum van x en y.
max(x,y) Geeft het maximum van x en y.
min3(x,y,z) Geeft het minimum van x, y en z.
max3(x,y,z) Geeft het maximum van x, y en z.
mean(x,y) Geeft het gemiddelde van x en y.

76
 point_distance(x1,y1,x2,y2) Geeft de afstand tussen punt (x1,y1) en
punt (x2,y2).
point_direction(x1,y1,x2,y2) Geeft de richting van punt (x1,y1) naar
punt (x2,y2) in graden.
is_real(x) Geeft true als x een reële waarde is en false als x een string is.
is_string(x) Geeft true als x een string is en false als x een reële waarde is.

24.3 String handling functies

De volgende functies worden gebruikt bij letters en strings.

chr(val) Geeft een string die het karakter bevat met ASCII code val.
ord(str)Geeft de ASCII code van het eerste karakter in str.
real(str) Verandert str in een reëel getal. Str kan een min teken bevatten een
decimale punt en zelfs een exponentieel deel.
string(val) Verandert de reële waarde in een string gebruik makend van het
standaard formaat (geen decimalen als het een geheel getal is en anders twee
decimalen).
string_format(val,tot,dec) Verandert val in een string gebruik makend
van je eigen formaat: tot geeft het totaal aantal plaatsen aan en dec geeft het
aantal decimalen aan.
string_length(str) Geeft het aantal karakters in de string.
string_pos(substr,str) Geeft de positie van substr in str (0=komt niet
voor).
string_copy(str,index,count) Geeft een substring van str, beginnend op
positie index en van lengte count.
string_delete(str,index,count) Geeft een kopie van str zonder het deel
met lengte count dat begint op positie index.
string_insert(substr,str,index) Geeft een kopie van str waaraan
substr op positie index is toegevoegd.
string_lower(str) Geeft een kopie van str in kleine letters.
string_upper(str) Geeft een kopie van str in hoofdletters
string_repeat(str,count) Geeft een string met daarin count kopieën van
str.
string_letters(str) Geeft een string met daarin alleen de letters van str.
string_digits(str) Geeft een string met daarin alleen de cijfers in str.
string_lettersdigits(str) Geeft een string met daarin de letters en
cijfers in str.

77
Hoofdstuk 25 GML: Het spelverloop
Er is een groot aantal variabelen en functies die je kunt gebruiken om het spel verloop te
definiëren. Deze beïnvloeden voornamelijk de beweging en het aanmaken van
instanties, de timing en het afhandelen van events.

25.1 Verplaatsen
Het moge duidelijk zijn dat een belangrijk aspect van spellen het bewegen van object
instanties is. Elke instantie heeft twee ingebouwde variabelen x en y die de positie van
de instantie aangeven. (Om precies te zijn, ze geven de plaats aan waar de oorsprong
van de sprite is geplaatst.) Positie (0,0) is de linkerbovenhoek van de kamer. Je kunt de
positie van de instantie veranderen door de variabelen x en y te veranderen. Als je het
object ingewikkelde bewegingen wilt laten maken is dit de manier om het te doen. Je
stopt deze code in het step event van het object.

Als het object met constante snelheid en richting beweegt, is er een makkelijker manier
om dit te doen. . Elke object instantie heeft een horizontale snelheid (hspeed) en een
verticale snelheid (vspeed). Beiden worden aangegeven in pixels per stap. Een
positieve horizontale snelheid betekent een beweging naar rechts, een negatieve
horizontale snelheid betekent een beweging naar links. Positieve verticale snelheid is
naar beneden en negatieve verticale snelheid is naar boven. Dus je hoeft deze
variabelen slechts een keer in te stellen (bijvoorbeeld bij het aanmaken) om de object
instantie een constante beweging te geven.

Er is nog een heel andere manier om beweging te specificeren, gebruik makend van een
richting (in graden 0-359), en een snelheid (mag niet negatief zijn). Je kunt deze
variabelen instellen en lezen om een willekeurige beweging te specificeren. (Intern wordt
dit vertaald in waarden voor hspeed en vspeed.) Verder is er ook nog wrijving en de
zwaartekracht en de richting van de zwaartekracht. Als laatste is er de functie
motion_add(dir,speed) om een beweging aan de huidige beweging toe te voegen.

Samengevat, elke instantie heeft de volgende variabelen en functies:

x Zijn x-positie.
y Zijn y-positie.
xprevious Zijn vorige x-positie.
yprevious Zijn vorige y-positie.
xstart De x-positie van zijn startpunt in de kamer.
ystart De y-positie van zijn startpunt in de kamer.
hspeed De horizontale component van de snelheid.
vspeed De verticale component van de snelheid.
direction Zijn huidige richting (0-360, tegen de klok in, 0 = naar rechts).
speed Zijn huidige snelheid (pixels per stap).
friction Huidige wrijving (pixels per stap).
gravity Huidige hoeveelheid zwaartekracht (pixels per stap).
gravity_direction Richting van de zwaartekracht (270 is naar beneden).
motion_set(dir,speed) Stelt de beweging in met de gegeven snelheid
(speed) en richting (dir)

78
 motion_add(dir,speed) Telt de beweging op bij de huidige beweging (als
een vector optelling).

Er is een groot aantal functies beschikbaar die je helpen je bewegingen te definiëren:

place_free(x,y) Geeft aan of de instantie op positie (x,y) botsingvrij is. Dit

wordt meestal gebruikt als een check voordat er naar een nieuwe positie wordt
bewogen.
place_empty(x,y) Geeft aan of the instantie op positie (x,y) niemand raakt.
Dus deze functie telt ook niet-solide instanties mee.
place_meeting(x,y,obj) Geeft aan of de instantie op positie (x,y) obj raakt.
Obj kan een object zijn, dan geeft de functie de waarde true als een instantie van
het object wordt geraakt. Het kan ook een instantie id zijn, het speciale woord
all (dat betekent een instantie van welk object dan ook), of het speciale woord
other.
place_snapped(hsnap,vsnap) Geeft aan of de instantie uitgelijnd is op een
raster.
move_random(hsnap,vsnap) Verplaatst de instantie naar een vrije
willekeurige rasterpunt, zoals de corresponderende actie.
move_snap(hsnap,vsnap) De instantie uitlijnen op raster zoals de
corresponderende actie.
move_towards_point(x,y,sp) Beweegt de instantie met snelheid sp naar
positie (x,y).
move_bounce_solid(adv) Stuiteren tegen massieve instanties, zoals de
corresponderende actie. Adv geeft aan of geavanceerd stuiteren, dat ook
schuine muren meerekent, gebruikt moet worden.
move_bounce_all(adv) Stuiteren tegen alle objecten in plaats van alleen
tegen massieve.
move_contact(dir) Beweegt de instantie in de richting totdat een contact
positie is bereikt. Als er geen botsing is op de huidige positie, wordt de instantie
geplaatst net voor een botsing plaatsvindt. Als er al een botsing is, wordt de
instantie verplaatst naar de eerste positie waar geen botsing meer is.

distance_to_point(x,y) Geeft de afstand van de grenzen van de huidige

instantie naar (x,y).
distance_to_object(obj) Geeft de afstand van de instantie naar de
dichtstbijzijnde instantie van object obj.

position_empty(x,y) Geeft aan of er niets staat op positie (x,y).

position_meeting(x,y,obj) Geeft aan of op positie (x,y) een instantie
object obj is. Obj kan een object zijn, een instantie id, of de sleutelwoorden self,
other, of all.

25.2 Instanties
In het spel zijn de instanties van de verschillende objecten de basis eenheden. Tijdens
het spel kun je een aantal aspecten van deze instanties veranderen. Je kunt ook nieuwe
instanties aanmaken en instanties vernietigen. Naast de variabelen die over beweging
gaan en die hierboven besproken zijn en de variabelen die over tekenen gaan en die
hieronder besproken worden, heeft elke instantie de volgende variabelen:

79
 object_index* Index van het object waar dit een instantie van is. Kan niet
veranderd worden.
id* De unieke identificatie van de instantie (>= 100000). (Merk op dat wanneer
je kamers definieert de id van de instantie onder de muis altijd aangegeven
wordt.)
mask_index Index van de sprite die gebruikt wordt als masker voor de
botsingen. Geef dit de waarde –1 om het hetzelfde te maken als de sprite_index.
solid Geeft aan of de instantie massief is. Dit kan veranderen tijdens het spel.
persistent Geeft aan of de instantie persistent is en weer zal verschijnen als
het verplaatst naar een andere kamer. Je wilt vaak de persistentie uitzetten op
bepaalde momenten. (Bijvoorbeeld als je teruggaat naar de eerste kamer.)

Er is één probleem als het gaat om instanties. Het is niet zo makkelijk om individuele
instanties te identificeren. Ze hebben namelijk geen naam. Als er slechts één instantie is
van een specifiek object kun je de objectnaam gebruiken, maar anders moet je de id van
de instantie zien te vinden. Dit is het unieke identificatienummer van de instantie. Je kunt
het in with statements gebruiken en als objectidentificeerder (gebruik makend van de
punt constructie beschreven in hoofdstuk 23.6). Gelukkig zijn er een aantal variabelen
en routines die je kunnen helpen de id van de instantie te vinden.

instance_count* Aantal instanties dat momenteel in de kamer bestaat.

instance_id[0..n-1]* De id van de specifieke instantie. Hier is n het
nummer van de instantie.

Laat me een voorbeeld geven. Neem aan dat elke eenheid in je spel een specifieke
gezondheid heeft en je wilt de sterkste lokaliseren, dan kun je de volgende code
gebruiken:

{
maxid = -1;
maxhealth = 0;
for (i=0; i<instance_count; i+=1)
{
iii = instance_id[i];
if (iii.object_index == unit)
{
if (iii.health > maxhealth)
{maxid = iii; maxhealth = iii.health;}
}
}
}

Na de loop bevat maxid de id van de eenheid met de grootste gezondheid. (Vernietig

geen instanties tijdens zo’n loop, want dat zullen ze automatisch verwijderd worden uit
de array en als een gevolg daarvan zul je instanties over gaan slaan.)

instance_find(obj,n) Geeft de id van de (n+1)de instantie van type obj. obj

kan een object zijn of het sleutelwoord all. Als het niet bestaat zal het speciale
object noone worden gegeven.

80
 instance_exists(obj) Geeft aan of er een instantie van object obj bestaat.
obj kan een object zijn, een instantie id of het sleutelwoord all.
instance_number(obj) Geeft het aantal instanties van type obj. obj kan een
object zijn of het sleutelwoord all.
instance_position(x,y,obj) Geeft de id van de instantie van type obj op
positie (x,y). Als er meer instanties zijn op die positie dan wordt de eerste
gegeven. obj kan een object zijn, of het sleutelwoord all. Als het niet bestaat,
wordt het speciale object noone gegeven.
instance_nearest(x,y,obj) Geeft de id van de instantie van type obj die
het dichtst bij (x,y) ligt. obj kan een object zijn of het sleutelwoord all.
instance_furthest(x,y,obj) Geeft de id van de instantie van type obj die
het verst weg van (x,y) ligt. obj kan een object zijn of het sleutelwoord all.
instance_place(x,y,obj) Geeft de id van de instantie van type obj die je
tegenkomt als de huidige instantie verplaatst wordt naar positie (x,y). obj kan een
object zijn of het sleutelwoord all. Als het niet bestaat wordt het speciale object
noone gegeven.

De volgende functies kunnen gebruikt worden om instanties te creëren en vernietigen:

instance_create(x,y,obj) Maakt een instantie van obj op positie (x,y). De

functie geeft de id van de nieuwe instantie.
instance_destroy()Vernietigt de huidige instantie.
instance_change(obj,perf) Verandert de instantie in obj. perf geeft aan of
de vernietiging en creëer events uitgevoerd moeten worden of niet.
position_destroy(x,y) Vernietigt alle instanties waarvan de sprite positie
(x,y) bevat.
position_change(x,y,obj,perf) Verandert alle instanties op positie (x,y)
in obj. perf geeft aan of de vernietiging en creëer events uitgevoerd moeten
worden of niet.

25.3 Timing
Goede spellen behoeven precieze timing van de dingen die gebeuren. Gelukkig doet
Game Maker de meeste timing voor je. Het zorgt ervoor dat dingen op een constante
niveau plaatsvinden. Dit niveau wordt gedefinieerd als de kamers worden gedefinieerd.
Maar je kan het veranderen gebruik makend van de globale variabele room_speed.
Dus je kunt bijvoorbeeld de snelheid van het spel langzamerhand toe laten nemen, om
het moeilijker te maken, door in elke stap een heel klein beetje (zoals 0,001) aan
room_speed toe te voegen. Als je machine traag is zou het kunnen dat de spelsnelheid
niet word gehaald. Dit kan gecontroleerd worden met de variabele fps die constant het
werkelijk aantal frames per seconde bijhoudt. Tenslotte kun je voor geavanceerde timing
de variabele current_time gebruiken die het aantal milliseconden geeft sinds de
computer gestart is. Hier is de totale collectie beschikbare variabelen (alleen de eerste
kan veranderd worden).

room_speed Snelheid van het spel in de huidige kamer.

fps* Het aantal frames dat werkelijk per seconde getekend wordt.
current_time* Aantal voorbije milliseconden sinds de computer werd
opgestart.

81
 current_year* Het huidige jaar.
current_month* De huidige maand.
current_day* De huidige dag.
current_weekday* De huidige dag van de week (1=zondag, …, 7=zaterdag).
current_hour* Het huidige uur.
current_minute* De huidige minuut.
current_second* De huidige seconde.

Soms wil je misschien het spel voor even stilleggen. Gebruik hiervoor de sleep functie.

sleep(numb)Het spel stopt voor numb milliseconden.

Tenslotte, zoals je weet heeft elke instantie 8 verschillende alarm klokken die je in kan
stellen. Om de waarden in te stellen (of op te vragen) van de verschillende klokken kun
je de volgende variabele gebruiken:

alarm[0..7] Waarde van de aangegeven alarmklok. (Merk op dat klokken

alleen aangepast worden als het alarm event van het object acties bevat!)

25.4 Kamers en score

Spellen werken in kamers. Elke kamer heeft een index die aangegeven wordt met de
naam van de kamer. De huidige kamer wordt opgeslagen in de variabelen kamer. Je
mag niet aannemen dat de kamers in opeenvolgende volgorde worden genummerd. Dus
je mag nooit een getal optellen of aftrekken van de kamer variabele. Gebruik in plaats
daarvan de functies en variabelen die hieronder staan. Dus een stukje code zou er
bijvoorbeeld zo uit kunnen zien:

{
if (room != room_last)
{
room_goto_next();
}
else
{
game_end();
}
}

Hier volgen de variabelen en functies die met kamer van doen hebben.

room Index van de huidige kamer; kan veranderd worden om naar een andere
kamer te gaan, maar je kunt beter de routines hieronder gebruiken.
room_first* Index van de eerste kamer in het spel.
room_last* Index van de laatste kamer in het spel.
room_goto(numb) Gaat naar de kamer met index numb.
room_goto_previous()Gaat naar de vorige kamer.
room_goto_next()Gaat naar de volgende kamer.
room_restart()Herstart de huidige kamer.

82
 room_previous(numb) Geeft de index van de kamer voor numb (-1 = geen),
maar gaat er niet heen.
room_next(numb) Geeft de index van de kamer na numb (-1=geen).
game_end()Eindigt het spel.
game_restart()Herstart het spel.

Kamers hebben een aantal extra eigenschappen:

room_width* Breedte van de kamer in pixels.

room_height* Hoogte van de kamer in pixels.
room_caption Titel string die te zien is in de titel van het venster.
room_persistent Geeft aan of een kamer persistent is.

Veel spellen geven de speler de mogelijkheid het spel op te slaan en een opgeslagen
spel te laden. In Game Maker gebeurt dit automatisch als de speler op <F5> drukt om
op te slaan en op <F6> om te laden. Je kunt ook opslaan en laden vanuit een stuk code
(merk op dat laden alleen plaatsvindt aan het einde van de huidige stap).

game_save(string) Sla het spel op naar het bestand met naam string.
game_load(string) Laad het spel van de file met naam string.

Een ander belangrijk aspect van veel spellen is de score en het aantal levens. Game
Maker houdt de score bij in de globale variabele score en het aantal levens in de
globale variabele lives. Beiden worden normaal gesproken weergegeven in de
venstertitel. Je kunt de score veranderen door simpelweg de waarde van deze variabele
te wijzigen. Hetzelfde geldt voor het aantal levens. Als lives groter dan 0 is en kleiner
of gelijk aan 0 wordt, wordt het no-more-lives event uitgevoerd voor alle instanties. (Je
kunt dit ook wijzigen in het options formulier.) Voor ingewikkelder spellen kun je beter
zelf de score weergeven.

score De huidige score.

lives Aantal levens
show_score Geeft aan of de score (en het aantal levens) weergegeven wordt.

Er is ook een ingebouwd mechanisme dat de highscore lijst bijhoudt. Het kan tot 10
namen bevatten. Voor meer informatie zie Hoofdstuk 29.

25.5 Events genereren

Zoals je weet is Game Maker volledig object gestuurd. Alle acties vinden plaats als
gevolg van events. Er is een aantal verschillende events. Creëer en vernietig events
komen voor als een instantie gemaakt of vernietigd wordt. In elke stap handelt het
systeem eerst de alarm events af. Daarna handelt het toetsenbord en muis events en
volgende stap events af. Hierna worden de instanties verzet naar hun nieuwe posities
nadat het botsing event is afgehandeld. Tenslotte wordt het teken event gebruikt om de
instanties te tekenen (merk op dat wanneer er meervoudige views zijn dat het teken
event dan meerdere malen aangeroepen wordt in één stap). Je kunt ook een event
toepassen op de huidige instantie vanuit een stuk code. De volgende functies bestaan:

83
 event_perform(type,numb) Voert event numb van type type uit op de
huidige instantie. De volgende event types kunnen ingevoerd worden:
ev_create
ev_destroy
ev_step
ev_alarm
ev_keyboard
ev_mouse
ev_collision
ev_other
ev_draw
Als er meerdere events zijn van het gegeven type, kan numb gebruikt worden om
het precieze event aan te geven. Het alarm event nummer kan variëren van 0 tot
7. Voor het toetsenbord moet je de toetscode gebruiken voor de toets. (zie
Hoofdstuk 26). Voor muis events kun je de volgende constanten gebruiken:
ev_left_button
ev_right_button
ev_middle_button
ev_no_button
Voor het botsing event geef je de index van het andere object. Tenslotte, je kunt
voor het andere event de volgende constanten gebruiken:
ev_outside
ev_boundary
ev_game_start
ev_game_end
ev_room_start
ev_room_end
ev_no_more_lives
ev_animation_end
Voor het stap event geef je de index. Je kunt de volgende constanten gebruiken:
ev_step_normal
ev_step_begin
ev_step_end
event_perform_object(obj,type,numb) Deze functie werkt hetzelfde als
die hierboven, behalve dat je hier events in een ander object kunt aangeven.
Merk op dat de acties in deze events worden toegepast in de huidige instantie,
niet in de instantie van het gegeven object.
event_user(numb) In het andere event kun je ook 8 gebruiker events
definiëren. Deze worden alleen uitgevoerd als je deze functie aanroept. Numb
moet tussen 0 en 7 liggen.
event_inherited()Voert het geërfde event uit. Dit werkt alleen als de
instantie een parent object heeft.

Je kan informatie krijgen over het huidige event dat wordt uitgevoerd met behulp van de
volgende read-only variabelen.
event_type* Type van het huidige event dat wordt uitgevoerd.
event_number* Nummer van het huidige event dat wordt uitgevoerd.
event_object* De object index waarvoor het huidige event wordt uitgevoerd.
event_action* De index van de actie die nu wordt uitgevoerd (0 is de eerste in
het event, enz.).

84
25.6 Diverse functies
Hier zijn een aantal andere functies die handig zijn in bepaalde gevallen.

object_name(ind) Geeft de naam van het object met de gegeven index.

room_name(ind) Geeft de naam van de kamer met de gegeven index.
sprite_name(ind) Geeft de naam van de sprite met de gegeven index.
background_name(ind) Geeft de naam van de achtergrond met de gegeven
index.
sound_name(ind) Geeft de naam van het geluid met de gegeven index.
script_name(ind) Geeft de naam van het script met de gegeven index.

85
Hoofdstuk 26 GML: Interactie met de gebruiker
Er bestaan geen spellen zonder interactie met de gebruiker. De standaard manier om dit
in Game Maker voor elkaar te krijgen is om acties (handelingen) te plaatsen in de mouse
of keyboard-events. Soms is het echter handig om daarover meer controle te krijgen.
Vanuit de code kun je namelijk nagaan welke specifieke toets van het toetsenbord is
ingedrukt, wat de positie van de muis op het beeldscherm is en of de knoppen van de
muis zijn ingedrukt.
Normaliter controleer je deze aspecten in de step event van een object en neem je actie
indien dat nodig zou zijn. De volgende variabelen en functies komen daarvoor in
aanmerking:

mouse_x* x-coördinaat van de muis. Read-only

mouse_y* y-coördinaat van de muis. Read-only
mouse_button Huidige ingedrukte muisknop. Gebruikt als waarden mb_none, mb_left,
mb_middle, of mb_right.
keyboard_lastkey De toetscode van de laatst ingedrukte toets. Hieronder staat een
overzicht van de toetscode constanten. Je kunt deze veranderen. Geeft de constanten
de waarde 0 indien je zelf de controle wilt overnemen.
keyboard_key Toetscode van de huidige ingedrukte toets.
keyboard_lastchar Welk karakter als laatste is ingetoetst (van het type string).
keyboard_string String die de laatste (maximaal 80) karakters bevat die ingetypt zijn.
De string bevat alleen de karakters die uitgeprint kunnen worden (zichtbaar gemaakt
kunnen worden) Het reageert tevens juist indien de backspace toets wordt ingedrukt.
Het laatste karakter dat is ingetoetst wordt dan verwijderd uit deze string.

Om na te gaan welke specifieke toets of muisknop is ingedrukt kunnen de volgende

functies worden gebruikt. Deze zijn handig indien meerdere toetsen gelijktijdig ingedrukt
worden.

keyboard_check(key) Geeft aan of de toets met toetscode key ingedrukt is.

keyboard_check_direct(key) Geeft aan of de toets met toetscode key ingedrukt is door
de hardware rechtstreeks te controleren.
Je kunt de volgende toetscodes gebruiken: vk_lshift, vk_lcontrol, vk_lalt, vk_rshift,
vk_rcontrol en vk_ralt (zie volgende pagina) (functioneert niet met onder Windows ‘95!).
mouse_check_button(numb) Geeft aan of de muisknop is ingedrukt (gebruik als
waarden mb_none, mb_left, mb_middle, or mb_right).

Hieronder staat een overzicht van de toetscode constanten:

vk_notoets toetscode die aangeeft dat er geen toets ingedrukt is.

vk_anytoets toetscode die aangeeft dat er een (willekeurige) toets ingedrukt is.
vk_left toetscode voor de linker pijltoets
vk_right toetscode voor de rechter pijltoets
vk_up toetscode voor de bovenste pijltoets
vk_down toetscode voor de onderste pijltoets
vk_enter enter toets
vk_escape escape toets
vk_space space toets
vk_shift shift toets

86
vk_control control toets
vk_alt alt toets
vk_backspace backspace toets
vk_tab tab toets
vk_home home toets
vk_end end toets
vk_delete delete toets
vk_insert insert toets
vk_pageup pageup toets
vk_pagedown pagedown toets
vk_pause pause/break toets
vk_printscreen printscreen/sysrq toets
vk_f1 … vk_f12 toetscodes voor the functietoeten F1 tot en met F12
vk_numpad0 … vk_numpad9 nummertoetsen van het numeriek toetsenblok
vk_multiply de vermenigvuldigingstoets op het numeriek toetsenblok
vk_divide de delingstoets op het numeriek toetsenblok
vk_add de opteltoets van het numeriek toetsenblok
vk_subtract de aftrekkingstoets van het numeriek toetsenblok
vk_decimal decimale dot toets van het numeriek toetsenblok

Voor de lettertoets kun je bijvoorbeeld ord('A') (hoofdletter) gebruiken. De volgende

constanten kunnen slechts gebruikt worden in keyboard_check_direct:

vk_lshift linker shift toets

vk_lcontrol linker control toets
vk_lalt linker alt toets
vk_rshift rechter shift toets
vk_rcontrol rechter control toets
vk_ralt rechter alt toets

Voorbeeld: Stel dat je een object hebt die je kan besturen met de vier pijltoetsen. Je
kunt de volgende code in de step event van het object plaatsen:

{
if (keyboard_check(vk_left)) x -= 4;
if (keyboard_check(vk_right)) x += 4;
if (keyboard_check(vk_up)) y -= 4;
if (keyboard_check(vk_down)) y += 4;
}

Het is natuurlijk veel gemakkelijker om deze in de keyboard events te plaatsen.

Zoals je waarschijnlijk al weet, is er de mogelijkheid (zie de spel opties) om aan te geven

of mouse- en keyboard events continu dienen te zijn (d.w.z. zolang de toets wordt
ingedrukt vindt er een event plaats) of niet-continu (slechts één event). Je kunt dit tevens
vanuit de code bereiken door gebruik te maken van de volgende variabelen:

keyboard_continuous Geeft aan of keyboard events continu moeten zijn (1) of niet (0).
mouse_continuous Geeft aan of mouse events continu moeten zijn (1) of niet (0).

Er zijn extra functies met betrekking tot interactie:

87
keyboard_clear(toets) Maakt de toestand waarin een toets zich bevindt leeg. Dit
betekent dat deze geen keyboard events meer kan veroorzaken, behalve bij herhaling.
mouse_clear(button) Maakt de toestand waarin de muisknop zich bevindt leeg. Dit
betekent dat de knop geen mouse events meer kan veroorzaken, behalve als deze
opnieuw ingedrukt wordt nadat hij losgelaten is.
io_clear() Maakt alle toestanden leeg, zowel voor de muis als voor het toetsenbord.
io_handle() Updaten toetsenbord and muis status.
keyboard_wait() Wacht totdat de gebruiker op een toets drukt.

26.1 Joystick ondersteuning

Game Maker ondersteunt het gebruik van een joystick. Bewegingen van een joystick
brengen keyboard events <NUMPAD>1 tot en met <NUMPAD>9 voort. De vier buttons
veroorzaken keyboard events voor de letters A,B,C en D.
Je kunt daarvoor niet de functie keyboard_check() gebruiken, want deze heeft
betrekking op het toetsenbord. Voor een joystick zijn er een aantal speciale functies
beschikbaar. Game Maker ondersteunt het gebruik van twee joysticks. Al deze functies
hebben als argument de id van de desbetreffende joystick.

joystick_exists(id) retourneert of de joystick met id (1 of 2) bestaat.

joystick_direction(id) retourneert de toetscode (vk_numpad1 t/m vk_numpad9)
afhankelijk van de richting van de joystick met id (1 or 2).
joystick_check_button(id,numb) retourneert indien een joystick knop is ingedrukt(1-4).
joystick_xpos(id) geeft de x-positie van de joystick (-1 tot 1)
joystick_ypos(id) geeft de y-positie van de joystick
joystick_zpos(id) geeft de z-positie van de joystick (indien deze een z-as heeft).

88
Hoofdstuk 27 GML: Spel graphics
Een belangrijk onderdeel van een spel zijn de graphics. Normaliter zorgt Game Maker
zelf voor het afhandelen van graphics en indien het zich handelt om eenvoudige
spelletjes hoef je je daarover dan ook geen zorgen te maken. Vaak wil je echter de
controle niet bij Game Maker leggen, maar wil je zelf invloed kunnen uitoefenen. Voor
een aantal aspecten zijn er actions beschikbaar, maar vanuit de code kun je veel meer
bewerkstelligen. Dit hoofdstuk geeft een beschrijving van alle variabelen en functies die
daarvoor gebruikt kunnen worden. Tevens wordt er dieper in gegaan op wat er eigenlijk
precies gebeurt.

27.1 Venster en cursor

Standaard speelt een spel zich af in een gecentreerd venster. De speler kan het venster
op fullscreen mode zetten door de <F4>- toets in te drukken, behalve als deze toets
disabled is. Je kunt dit tevens bewerkstelligen vanuit het programma zelf. De volgende
variabele wordt daarvoor gebruikt:

full_screen Deze variabele heeft de waarde true indien de window in fullscreen

mode is. De mode is te veranderen door aan deze variabele de waarde true of
false toe te kennen.

Merk op dat in fullscreen mode the caption en de score zichtbaar worden op het scherm.
(Dit kun je omzeilen door de spelopties te gebruiken.) In full screen mode is het image
gecentreerd of op schaal. Om dit te besturen wordt de volgende variabele gebruikt:

scale_screen Deze variabele heeft de waarde true indien in scaled mode. De

mode is te veranderen door aan deze variabele de waarde true of false toe te
kennen.

Bij gebruik van een langzame processor of grafische kaart kan het zijn dat de scaled
mode langzaam werkt. Standaard wordt ieder spel gespeeld met de cursor zichtbaar op
het scherm. Omdat bij sommige spelletjes de aanwezigheid van een cursor irritant kan
zijn, kun je deze verwijderen door gebruik te maken van de volgende variabele:

show_cursor Deze variabele heeft de waarde false indien de cursor onzichtbaar

is op het beeldscherm

Let op, het is vrij makkelijk om je eigen cursor object te maken. Maak een of ander
object met een negatieve diepte (depth). In de step event van dit object., laat je deze de
muis gewoon achtervolgen.

Om de resolutie van je monitor te vinden, kun je gebruik maken van de volgende twee,
read-only, variabelen:

monitor_width* De breedte of the monitor, in pixels.

monitor_height* De hoogte of the monitor, in pixels.

89
27.2 Sprites en plaatjes
Ieder object wordt geassocieerd met een sprite. Dit is één enkele afbeelding, maar hij
kan ook bestaan uit meerdere afbeeldingen.
Voor iedere instantie van het object tekent het programma de bijbehorende afbeelding
op het beeldscherm, waarbij de basis (zoals gedefinieerd in de sprite eigenschappen) op
positie (x,y) van deze instantie ligt.

Indien er sprake is van meerdere afbeeldingen, verspringt het van afbeelding naar
afbeelding en zo ontstaat er een animatie effect. Er zijn een aantal variabelen die
invloed hebben op de manier waarop de afbeelding getekend worden. Deze kunnen
gebruikt worden om de effecten te veranderen. Iedere instantie heeft de volgende
variabelen:

visible Indien visible de waarde true (1) heeft, wordt de afbeelding getekend en
anders niet. Onzichtbare instanties zijn nog steeds actief en kunnen collision
effects veroorzaken; al zie je deze niet. Het is handig om visible de waarde
false(0) toe te kennen bij bijvoorbeeld controller objecten (maak ze non-solid om
botsingen te voorkomen) en hidden switches.
sprite_index Dit is de index van de huidige sprite van de instantie. Dit kun je
veranderen door de instantie een andere sprite toe te kennen. Als waarde
gebruik je de namen van de verschillende door jou gedefinieerde sprites. De
index van het nu aanwezige zichtbare subplaatje verandert niet bij het
veranderen van de sprite.
sprite_width* Geeft de breedte van de sprite aan.
sprite_height* Geeft de hoogte van de sprite aan.
sprite_xoffset* Geeft de horizontale offset van de sprite aan, zoals gedefinieerd
in de sprite eigenschappen.
sprite_yoffset* Geeft de verticale offset van de sprite aan, zoals gedefinieerd in
de sprite eigenschappen.
image_number* het nummer van de subplaatjes van de huidige sprite van de
instantie.
image_index Indien de image meerdere subplaatjes bevat verspringt het
programma van subplaatje naar subplaatje. Deze variabele geeft de index van
het huidig getekende subplaatje aan (nummering begint bij 0!) Door het
veranderen van deze variabele, verander je het huidige image. Het programma
gaat door met het verspringen van subplaatje naar subplaatje, beginnende bij
deze nieuwe index.
image_single Soms wil je dat een bepaald subplaatje zichtbaar is, maar je wilt
niet dat het programma door alle subplaatjes springt. Dit kun je bereiken door
aan deze variabele de index van de subplaatje mee te geven die je wilt zien.
(eerste subplaatje heeft index 0). Geef je de variabele de waarde –1 dan
verspringt het programma weer door de subplaatjes. Dit is handig wanneer een
object verschillende verschijningen heeft. Bijvoorbeeld: Stel je voor dat je een
object hebt dat kan draaien. je maakt een sprite bestaande uit een aantal
subplaatjes met verscheidene oriëntatiepunten (tegen de klok in). In de step
event van het object kun je het volgende zetten:

{
image_single = direction * image_number/360;
}

90
 image_speed De snelheid waarmee het programma van subplaatje naar
subplaatje verspringt. Een waarde van 1 betekent dat bij iedere stap naar de
volgende subplaatje wordt gegaan. Kleinere waarden maken dat de images
langzamer wisselen. Elke subplaatje wordt verscheidene keren getekend.
Grotere waarden slaan subplaatjes over om de beweging sneller te maken.
depth In het algemeen worden de images getekend in de volgorde waarop de
instanties gemaakt zijn. Met behulp van deze variabele kun je dit veranderen. De
standaard waarde is 0.
Hoe hoger de waarde des te verder weg de instantie. Je kunt ook negatieve
waarden gebruiken. Instanties waarbij de variabele depth een hogere waarde
heeft zullen achter de instanties liggen met een lagere waarde. Door deze
variabele te wijzigen worden de instanties getekend in de door jou gekozen
volgorde ( bijvoorbeeld het vliegtuig voor de wolk). Achtergrond instanties
hebben dus een hogere (positieve) depth. Voorgrond instanties hebben dus een
lagere(negatieve) depth.
image_scale Een schalingsfactor om afbeeldingen groter dan wel kleiner te
maken. een factor van 1 betekent een normale grootte. Veranderen van schaal
betekent heeft invloed op de breedte en hoogte van de afbeelding en beïnvloed
de collision events.
Realiseer je dat op schaal gemaakte afbeeldingen (vooral als je ze kleiner
maakt) meer tijd kosten bij het tekenen. Het veranderen van de schalingsfactor
veroorzaakt een 3D effect.
bbox_left* Linkerzijde van de bounding box van de bij de instantie behorende
afbeelding
bbox_right* rechterzijde van de bounding box van de bij de instantie behorende
afbeelding
bbox_top* bovenzijde van de bounding box van de bij de instantie behorende
afbeelding
bbox_bottom* onderzijde van de bounding box van de bij de instantie
behorende afbeelding

Sprites nemen veel geheugen in beslag. Om deze snel genoeg te kunnen tekenen is het
handig om de afbeeldingen in het videogeheugen te plaatsen. Zoals reeds is besproken
in Hoofdstuk 13, kun je aangeven welke sprites er in dit geheugen moeten worden
geplaatst. Je kunt ook aangeven dat bepaalde sprites alleen geladen dienen te worden
indien nodig is. Deze sprites worden weer uit dit geheugen geplaatst aan het eind van
de level. Je kunt dit proces gedeeltelijk vanuit de code beïnvloeden. De volgende
functies komen daarvoor in aanmerking:

sprite_discard(numb) Maakt het videogeheugen dat gebruikt wordt voor de

sprite leeg. Indien de sprite de eigenschap load-on-use heeft, zal deze volledig
uit het geheugen verwijderd worden. En zo niet wordt er een copy van de sprite
in het gewone geheugen bewaard, zodat de sprite wederom in het video
geheugen geladen kan worden, indien dat nodig zou zijn.
sprite_restore(numb) Laadt de sprite (wederom) in het video geheugen.
Normaliter gebeurt dit automatisch indien de sprite nodig is. Dit kan echter een
kleine verstoring veroorzaken, vooral bij load-on-use en tevens wanneer de
sprite groot is

91
 discard_all() verwijdert alle sprites, achtergronden en geluid met eigenschap
load-on-use.

Indien een spel veelvuldig gebruik maakt van verschillende grote sprite afbeeldingen,
wordt het spelbestand groot, met als gevolg dat het laden van het spel zeer lang kan
duren. Indien je deze in het geheugen wilt behouden, totdat je deze gaat gebruiken, is
dat een belasting voor het geheugen.
Je kunt te samen met het spel de benodigde sprites ( .bmp, .jpg, or .gif files;
andere formaten zijn niet toegestaan) apart aanleveren. Gedurende het spel
worden ze geladen.
Er zijn drie routines om dit voor elkaar te krijgen:

sprite_add(fname,imgnumb,precise,transparent,videomem,loadonuse,xorig,y
orig) Voegt de afbeelding met naam fname toe aan de verzameling sprites
(alleen .bmp, .jpg en .gif), transparent duidt aan of de afbeelding gedeeltelijk
transparant is, videomem duidt aan of de afbeelding in het video geheugen
geplaatst dient te worden en loadonuse duidt aan of de afbeelding in het
geheugen geplaatst dient te worden als je deze daadwerkelijk gaat gebruiken (en
anders niet). xorig en yorig geven de positie van de originele sprite aan. De
functie geeft de index van de nieuwe sprite. Je kunt de index toewijzen aan de
variabele sprite_index van een instantie. De functie geeft waarde –1 bij een
foutmelding.
Gebruik imgnumb om de nummers van de afbeeldingen aan te geven (1 voor
een enkel plaatje). Doe dit alleen bij .bmp of .jpg wanneer deze als een strip zijn
opgeslagen bestaande uit een aantal subimages van de sprite naast elkaar.
Voor (animated) gifs, wordt dit argument niet gebruikt.
precise duidt aan of precise collision detectie gebruikt moet worden.

sprite_replace(ind,fname,imgnumb,precise,transparent,videomem,loadonuse
,xorig,yorig) heeft dezelfde eigenschappen als de functie hierboven, alleen
wordt nu de sprite (met index ind) vervangen. De functie geeft aan of dit
succesvol is verlopen.

sprite_delete(ind) Verwijdert de sprite uit het geheugen. Geheugen wordt

vrijgegeven. De sprite kan niet meer in het geheugen worden geplaatst.

WAARSCHUWING: Indien je het spel tijdens de uitvoering opslaat, worden de

toegevoegde of de te vervangen sprites NIET opgeslagen. Begin je het spel op een later
tijdstip dan kan het voorkomen dat de sprites weg zijn.

27.3 Achtergronden
Iedere room kan maximaal 8 achtergronden bevatten. Iedere room heeft verder een
achtergrondkleur. Alle aspecten van de achtergronden kunnen in de code worden
veranderd door gebruik te maken van de volgende variabelen: (Merk op dat sommige
variabelen van het type array zijn met indices 0 tot en met 7)

background_color Achtergrondkleur van de room.

background_showcolor Of het venster geschoond moet worden in de
achtergrondkleur.

92
 background_visible[0..7] Of de achtergrond zichtbaar is.
background_foreground[0..7] Of de achtergrond eigenlijk een voorgrond is.
background_index[0..7] de index van de achtergrondafbeelding
background_x[0..7] X positie van de achtergrondafbeelding
background_y[0…7] Y positie van de achtergrondafbeelding
background_width[0…7]* Breedte van de achtergrondafbeelding
background_height[0…7]* Hoogte van de achtergrondafbeelding
background_htiled[0..7] Of horizontaal getegeld moet worden.
background_vtiled[0..7] Of verticaal getegeld moet worden.
background_hspeed[0..7] Horizontale scrolling speed van de achtergrond
(aantal pixels per stap).
background_vspeed[0..7] Verticale scrolling speed van de achtergrond (aantal
pixels per stap).

Achtergrondafbeeldingen nemen veel geheugen in beslag. Om deze snel genoeg te

kunnen tekenen is het handig om de afbeeldingen in het videogeheugen te plaatsen.
Zoals reeds is besproken in Hoofdstuk 15 kun je aangeven welke achtergronden er in dit
geheugen moeten worden geplaatst. Je kunt ook aangeven dat bepaalde achtergronden
alleen geladen dienen te worden wanneer deze gebruikt worden. Deze achtergronden
worden weer uit dit geheugen geplaatst aan het eind van de level. Je kunt dit proces
gedeeltelijk vanuit de code beïnvloeden. De volgende functies komen daarvoor in
aanmerking:

background_discard(numb)
Maakt het videogeheugen dat gebruikt wordt voor de achtergrondafbeelding
leeg. Indien de achtergrond de eigenschap load-on-use heeft, zal deze volledig
uit het geheugen worden verwijderd. En zo niet wordt er een kopie van de
achtergrondafbeelding in het gewone geheugen bewaard, zodat de deze
wederom in het video geheugen geladen kan worden, indien dat nodig zou zijn.
background_restore(numb) Laadt de achtergrondafbeelding (wederom) in het
video geheugen. Normaliter gebeurt dit automatisch indien de achtergrond nodig
is. Dit kan echter een kleine verstoring veroorzaken, vooral bij load-on-use en
tevens wanneer de achtergrond te groot is
discard_all() verwijdert alle sprites, achtergronden en geluid met eigenschap
load-on-use.

Indien een spel veelvuldig gebruik maakt van verschillende achtergrondafbeeldingen

wordt het spelbestand groot, met als gevolg dat het laden van het spel zeer lang kan
duren. Indien je deze in het geheugen wilt behouden, wordt het geheugen aanzienlijk
belast.
Je kunt samen met het spel de benodigde afbeeldingen ( .bmp, .jpg, of .gif files;
andere formaten zijn niet toegestaan) apart aanleveren. Gedurende het spel
worden ze geladen.
Dit is ook handig wanneer je de speler de mogelijkheid geeft zelf een
achtergrond te kiezen.
Er zijn drie routines om dit voor elkaar te krijgen:

background_add(fname,transparent,videomem,loadonuse) Voegt de
achtergrondafbeelding met naam fname toe aan de verzameling achtergronden

93
 (alleen .bmp en .jpg), transparent duidt aan of de afbeelding gedeeltelijk
transparant is, videomem duidt aan of de afbeelding in het videogeheugen
geplaatst dient te worden en loadonuse duidt aan of de afbeelding in het
geheugen geplaatst dient te worden als je deze daadwerkelijk gaat gebruiken (en
anders niet). De functie geeft de index van de nieuwe afbeelding. Je kunt de
index toewijzen aan de variabele background_index[0] om deze zichtbaar te
maken in de room. De functie geeft waarde –1 bij een foutmelding.

background_replace(ind,fname,transparent,videomem,loadonuse) Deze
functie is nagenoeg dezelfde als die van hierboven, alleen wordt nu de
achtergrond met index ind vervangen. De functie retourneert of het succesvol
uitgevoerd is. Indien de achtergrond zichtbaar is in de room, wordt deze tevens
vervangen.

background_delete(ind) Wist de achtergrond uit het geheugen. Het geheugen

wordt vrijgegeven. De achtergrond kan niet wederom in het geheugen geladen
worden.

WAARSCHUWING: Indien je het spel tijdens de uitvoering opslaat, worden de

toegevoegde of de te vervangen afbeeldingen NIET opgeslagen. Begin je het spel op
een later tijdstip dan kan het voorkomen dat de afbeeldingen weg zijn.

27.4 Functies die gebruikt worden voor tekenen

Het is mogelijk om de objecten er anders uit te laten zien dan de bijbehorende images.
Er is een heel scala aan functies beschikbaar om verschillende vormen te tekenen. Er
zijn ook functies die tekst tekenen. Je kunt de functies alleen gebruiken in de drawing
event van een object; indien de functies ergens anders in de code worden toegevoegd
heeft dit geen effect.( hoewel: zie paragraaf 27.7)

De snelheid waarmee een tekening gemaakt wordt, is slechts afhankelijk van de

grafische kaart (hardware). Ieder andere teken routine zal relatief langzaam zijn.

Game Maker is geoptimaliseerd met betrekking tot het tekenen van plaatjes. Gebruik
indien mogelijk geen andere teken routines. Kan het niet anders, neem een bitmap.
Botsingen tussen instanties worden bepaald door de bijbehorende sprites (of maskers)
en niet door datgene wat je hebt getekend.
De volgende functies kun je gebruiken bij het tekenen:

draw_sprite(n,img,x,y) Tekent subplaatje img (-1 = huidige) van de sprite met

index n met de oorsprong in positie (x,y).
draw_sprite_scaled(n,img,x,y,s) Tekent de sprite met schalingsfactor s.
draw_sprite_stretched(n,img,x,y,w,h) Tekent de sprite uitgerekt zodat een
gebied gevuld wordt, vanuit (x,y) geheel linksboven met breedte w en hoogte h.
draw_sprite_transparent(n,img,x,y,s,alpha) Tekent de sprite met
schalingsfactor s samengesmolten met de achtergrond.
alpha duidt op dekkingsfactor. Een waarde van 0 betekent geheel transparant.
Een waarde van 1 betekent geheel dekkend. Deze functie kan een leuk effect
bewerkstelligen (bijvoorbeeld deels transparante explosies). Het is echter erg
traag, omdat het softwarematig bewerkstelligd wordt. Je moet er dus zorgvuldig
mee om gaan.

94
 draw_background(n,x,y) Tekent de achtergrond met index n op positie (x,y).
draw_background_scaled(n,x,y,s) Tekent the achtergrond met een
schalingsfactor.
draw_background_stretched(n,x,y,w,h) Tekent the achtergrond uitgerekt zoals
is aangegeven in de parameters.
draw_background_transparent(n,x,y,s,alpha) Tekent the achtergrond met
schalingsfactor s en dekkingsfactor alpha (0-1). (traag!).
draw_background_tiled(n,x,y) Betegelt de achtergrond zodat deze de gehele
room vult.

De volgende teken functies tekenen basisfiguren. Ze maken gebruik van een aantal
eigenschappen.in het bijzonder voor brush en pen color. Deze kunnen ingesteld worden
met behulp van een aantal variabelen

draw_pixel(x,y) Tekent een pixel op positie (x,y) in brushkleur.

draw_getpixel(x,y) Geeft de waarde terug van de kleur van een pixel in (x, y)
draw_fill(x,y) Het vlak waarin positie (x,y) ligt wordt gevuld met de brushkleur.
draw_line(x1,y1,x2,y2) Tekent een lijn van (x1, y2) tot (x2, y2)
draw_circle(x,y,r) Tekent een cirkel met middelpunt (x, y) en straal r.
draw_ellipse(x1,y1,x2,y2) Tekent een ellips.
draw_rectangle(x1,y1,x2,y2) Tekent een rechthoek.
draw_roundrect(x1,y1,x2,y2) Tekent een afgeronde rechthoek.
draw_triangle(x1,y1,x2,y2,x3,y3) Tekent een driehoek.
draw_arc(x1,y1,x2,y2,x3,y3,x4,y4) Tekent een boog van een ellips
draw_chord(x1,y1,x2,y2,x3,y3,x4,y4) Tekent een koorde van een ellips
draw_pie(x1,y1,x2,y2,x3,y3,x4,y4) Tekent een taartpunt van een ellips
draw_button(x1,y1,x2,y2,up) Tekent een button, (1) voor omhoog en (0) voor
omlaag.
draw_text(x,y,string) Tekent de string op position (x,y).

Je kunt een aantal instellingen (variabelen) veranderen, bijvoorbeeld de kleur van de

lijnen (pen), de kleur van de opvulling (brush) en het lettertype en vele andere
lettereigenschappen. De effect van de variabelen is globaal. Indien je de instellingen
gaat veranderen, gelden deze veranderingen tevens voor iedere figuur die je wilt
tekenen. Je kunt deze variabelen tevens gebruiken in andere events. Als ze
bijvoorbeeld niet veranderen hoef je ze maar één keer bij de start van het spel in te
stellen.

brush_color Kleur om vormen mee te kunnen vullen. Een scale aan

voorgedefinieerde kleuren is beschikbaar. Deze zijn:
c_aqua
c_black
c_blue
c_dkgray
c_fuchsia
c_gray
c_green

95
 c_lime
c_ltgray
c_maroon
c_navy
c_olive
c_purple
c_red
c_silver
c_teal
c_white
c_yellow
Door gebruik te maken van de routine make_color(red,green,blue) kunnen
andere kleuren worden gemaakt. Red, green en blue hebben waarden tussen 0
en 255 (rgb kleuren).
brush_style Huidige stijl van de brush om figuren mee op te vullen. De volgende
stijlen zijn beschikbaar:
bs_hollow
bs_solid
bs_bdiagonal
bs_fdiagonal
bs_cross
bs_diagcross
bs_horizontal
bs_vertical
pen_color Kleur van de pen om grenzen mee te tekenen.
pen_size Grootte van de pen in pixels.
font_color Kleur van het gebruikte font.
font_size Grootte van het gebruikte font (in pt).
font_name Naam van het font (een string variabele).
font_style Stijl van het font. De volgende stijlen zijn beschikbaar:
fs_normal
fs_bold
fs_italic
fs_bolditalic
font_angle De hoek van het desbetreffende font (0-360 graden). Bijvoorbeeld:
voor verticale tekst gebruik je 90.
font_align Uitlijningen van de tekst. De volgende waarden kunnen gebruikt
worden:
fa_left
fa_center
fa_right

Nog een aantal andere functies:

string_width(string) Breedte van de string in de huidige fontinstelling. Handig bij

het uitlijnen.
string_height(string) Hoogte van de string in de huidige fontinstelling.

96
 screen_gamma(r,g,b) Gamma correctie waarden. r,g,b liggen tussen –1 en 1
De standaard waarde is 0. gebruik je een waarde kleiner dan 0, wordt de kleur
donkerder. En andersom lichter. In de meeste gevallen veranderen de waarden
van r,g,b niet. Het kan echter handig zijn om tijdelijk de waarden te veranderen.
Denk eens aan het creëren van bliksem. De waarden zitten dan dicht bij 1. De
functie werkt alleen in exclusive mode!
screen_save(fname) Slaat het beeldscherm op als bmp. Handig bij het maken
van screen shots. Deze afbeelding krijgt naam fname.
screen_save_part(fname,left,top,right,bottom) Slaat een gedeelte van het
scherm op als bitmap. Deze krijgt naam fname.

27.5 Views
Zoals je waarschijnlijk al weet kun je maximaal 8 verschillende views definiëren. Op die
manier kun je bijvoorbeeld verschillende delen van de room op verschillende plaatsen
op het scherm laten zien.
Je kunt er tevens voor zorgen dat een object altijd zichtbaar blijft. Het besturen van de
verschillende views kan vanuit de code gerealiseerd worden. Je kunt views zichtbaar of
onzichtbaar maken en de plaats en afmetingen van een view op het beeldscherm of de
positie van de view in de room veranderen (dit is in het bijzonder handig als je geen
enkel object hebt aangeven dat zichtbaar moet zijn.). Je kunt ook de afmeting van zowel
de horizontale als verticale rand rond een zichtbaar object veranderen en je kunt
aangeven welk object zichtbaar moet blijven in de views. Dit laatste is zeer belangrijk als
tijdens het spel het belangrijke object verandert. Je wilt soms bijvoorbeeld het
hoofdfiguurobject veranderen naar aanleiding van zijn huidige status. Helaas betekent
dit dat het object dan niet langer zichtbaar hoeft te blijven. Dit kan verholpen worden
door één regel code het creation event van alle mogelijke hoofd objecten (ervan
uitgaande dat dit in de eerste view moet gebeuren):

{
view_object[0] = object_index;
}

De volgende variabelen hebben invloed op de view. Al deze variabelen, behalve de

eerste twee, zijn van het type array, lopend van 0 (de eerste view) tot 7 (de laatste view):

view_enabled Geeft aan of views enabled zijn of niet.

view_current* De huidige getekende view (0-7). Gebruik deze alleen in de
drawing event. Read-only
view_visible[0..7] Geeft aan of een bepaalde view zichtbaar is op het scherm.
view_left[0..7] linkse positie van de view in de room
view_top[0..7] Top positie van de view in de room
view_width[0..7] Breedte van de view (in pixels).
view_height[0..7] Hoogte van de view (in pixels)
view_x[0..7] x -positie van de view op het scherm
view_y[0..7] y-positie van de view op het scherm
view_hborder[0..7] Afmeting van de horizontale rand rond het zichtbare object
(in pixels)
view_vborder[0..7] Afmeting van de verticale rand rond het zichtbare object (in
pixels)
view_hspeed[0..7] Maximale horizontale snelheid van de view.

97
view_vspeed[0..7] Maximale verticale snelheid van de view.
view_object[0..7] Objecten waarvan de instanties zichtbaar moeten blijven in de
view.

98
Hoofdstuk 28 Geluid en muziek
Geluid speelt een belangrijke rol in computerspellen. Er zijn twee soorten geluid:
achtergrondmuziek en geluidseffecten. Achtergrondmuziek is van het bestandsformaat
midi. Kenmerkend voor achtergrondmuziek is dat deze oneindig vaak herhaald kan
worden. Geluidseffecten zijn korte wavebestanden. Om optimaal gebruik te kunnen
maken van geluidseffecten dienen deze van tevoren in het geheugen te worden
geplaatst. Zorg er dus voor dat deze niet te groot zijn.

Geluidsfragmenten wordt aan het spel toegevoegd in de vorm van geluidsbronnen. Zorg
ervoor dat de namen van de geluidsbronnen correct zijn.

Het systeem kan een wavebestand slechts één maal achter elkaar afspelen. Indien je
hetzelfde bestand nogmaals gaat afspelen en de vorige is nog niet afgelopen, wordt
deze gestopt. Aantrekkelijk is dit niet..

Dus als je een geluidseffect hebt die meerdere keren achter elkaar dienen te worden
afgespeeld (bijvoorbeeld bij een kogelsalvo) moet je het bestand meerdere keren
opslaan. Je gebruikt daarvoor de buffers. Bij het gebruik van meer buffers kan het geluid
vaker worden afgespeeld. Dit kost echter meer geheugen. Let daar een beetje op.

Er zijn vier basisfuncties die betrekking hebben op geluid, twee ervan worden gebruikt
om geluid af te spelen, één om te controleren of geluid inderdaad wordt afgespeeld en
één om het geluid te stoppen.
Als argument van al deze functies wordt de index genomen. De index is niets anders
dan de naam van de geluidsbron. Je kunt de index ook als variabele opslaan.

sound_play(index) Speelt het aangegeven geluid slechts één keer.

sound_loop(index) Speelt het aangegeven geluid oneindig vaak herhaald
sound_stop(index) Stopt het aangegeven geluid. Indien er meerdere geluiden
met dezelfde index gelijktijdig worden afgespeeld, stoppen alle geluiden.
sound_isplaying(index) Geeft de index van het geluid dat momenteel wordt
afgespeeld.

Het is ook mogelijk om geluidseffecten te gebruiken. Dit zijn wavebestanden en geen

midibestanden. Wil je gebruik maken van geluidseffecten, moet je dit aangeven in de
Advanced tab van het menu Sound properties.
Merk even op dat geluidsfragmenten waarbij gebruikt wordt gemaakt van effecten meer
geheugen kosten.
Er zijn drie soorten geluidseffecten. Allereerst kun je het volume regelen. Een waarde
van 0 betekent dat er geen geluid is. Een waarde van 1 komt overeen met het volume
van het oorspronkelijke geluid. (Je kunt het volume niet luider zetten dan het volume van
het oorspronkelijke geluid.)

Je kunt tevens de balans veranderen (vanuit welke richting het geluidsfragment moet
komen). Een waarde van 0 duidt op geheel van links en een waarde van 1 duidt op
geheel van rechts. 0.5 is de standaardwaarde: van beide kanten. Het veranderen van
balans wordt bijvoorbeeld gebruikt om aan te geven dat een object zich van links naar
rechts aan het verplaatsen is. Je kunt ook de frequentie van het geluidsfragment
veranderen. Een waarde van 0 duidt op een lage frequentie (langzaam) en een waarde

99
van 1 duidt op een hoge frequentie (snel). Je kunt met behulp van de frequentie
bijvoorbeeld de motor van een raceauto mee simuleren.

sound_volume(index,value) Verandert het volume van het geluid (0=zacht, 1=

hard)
sound_pan(index,value) Verandert de balans van het geluid (0=links, 1=rechts)
sound_frequency(index,value) Verandert de frequentie van het geluid (0=laag,
1= hoog)

Geluidsfragmenten vergen veel capaciteit en veel systemen kunnen slechts een aantal
geluidsfragmenten afspelen dan wel opslaan. Je wilt (vooral bij grote spellen) meer
controle hebben over welke fragmenten er in het geheugen moeten worden geplaatst en
welke niet (en op welke momenten). Je kunt daarvoor de optie load-on-use gebruiken.
Je bent er dan zeker van dat jij de controle hebt. Dit kan echter een kleine verstoring
veroorzaken. Indien je slechts één room hebt, heb je er tevens niets aan.
Om het geheel naar eigen hand te zetten worden de volgende drie routines gebruikt:

sound_discard(index) Maakt het geheugen dat gebruikt wordt voor het geluid
leeg
sound_restore(index) Laadt het geluid (wederom) in het geheugen..
discard_all() Verwijdert alle sprites, achtergronden en geluidsfragmenten met
eigenschap load-on-use.

Indien een spel veelvuldig gebruik maakt van verschillende grote geluidsfragmenten
(bijvoorbeeld achtergrond muziek), wordt het spelbestand groot, met als gevolg dat het
laden van het spel zeer lang kan duren. Indien je deze in het geheugen wilt behouden,
totdat je deze gaat gebruiken, is een belasting voor het geheugen.

Je kunt de geluidsbestanden als een aparte file bij het spel voegen. Gedurende het spel
worden ze in het geheugen geladen. Er zijn drie routines om dit voor elkaar te krijgen:

sound_add(fname,buffers,effects,loadonuse)
Voegt de geluidsbron met naam fname toe aan het spel, buffers duidt op het
aantal buffers dat er gebruikt wordt, and effects and loadonuse duiden aan of
het gebruik van geluidseffecten is toegestaan en of het geluidsfragment wel
(true) of niet (false0 in het geheugen moet worden geplaatst.
De functie geeft de index van het nieuwe geluidsfragment, dit kan gebruikt
worden om het fragment daadwerkelijk af te spelen( –1 bij een
foutmelding d.w.z. geluidsbron bestaat niet).

sound_replace(index,fname,buffers,effects,loadonuse) heeft dezelfde

eigenschappen als de functie hierboven, alleen wordt nu het geluidsfragment
(met index ind) vervangen. De functie retourneert indien succesvol.
sound_delete(index) Verwijdert het geluid uit het geheugen. Geheugen wordt
vrijgegeven. Het geluidsfragment kan niet meer in het geheugen worden
geplaatst.

100
WAARSCHUWING: Indien je het spel tijdens de uitvoering opslaat, worden het
toegevoegde of het te vervangen geluidsfragment NIET opgeslagen. Begin je het spel
op een later tijdstip dan kan het voorkomen dat het geluidsfragment weg zijn.

Het gebruik van geluidsfragmenten is ingewikkeld. Midi files worden afgespeeld op de

een multimedia player. Slechts één midi files kan er tegelijkertijd worden afgespeeld. Bij
dit type is er geen ondersteuning voor geluidseffecten.

Bij Wave files wordt door Game Maker gebruik gemaakt van DirectSound.
In dit geval worden alle wave files in het geheugen geplaatst en kan er gebruik worden
gemaakt van geluidseffecten. Game Maker speelt tevens mp3 files af. Hij gebruikt
daarvoor de standaard multimedia player. Niet iedere multimedia player ondersteunt
mp3. Pas op.

101
Hoofdstuk 29 GML: Splash screens, highscores, en
andere popup vensters
Veel spellen maken gebruik van zogenaamde splash screens. Deze schermen laten een
videofragment, een afbeelding of tekst zien. Ze worden veelal in het begin van een spel
(als intro), aan het begin van iedere nieuwe level, of aan het eind van het spel
(puntenscores) getoond.
In Game Maker kunnen splash screens op ieder moment in het spel worden getoond.
Het spel wordt dan tijdelijk onderbroken. Indien de splash screen verdwijnt, wordt het
spel voortgezet.
Hieronder staat een overzicht van de functies:

show_text(fname,full,backcol,delay) Toont een splash screen met tekst.

fname is de naam van de tekstfile (.txt of .rtf). De file moet in dezelfde map
komen te staan waar het spel staat. Idem wanneer er een stand-alone versie
(een executable) van het spel gemaakt wordt. full geeft aan of de splash screen
in full screen mode getoond moet worden. backcol is de achtergrondkleur van
de splash screen. delay is de vertraging (delay) in seconden voordat je
terugkeert naar het spel. (De speler kan altijd deze tijd inkorten door het de muis
in het desbetreffende scherm te klikken. Het spel wordt voortgezet).

show_image(fname,full,delay) Toont een splash screen met een afbeelding.

fname is de naam van de afbeelding (alleen .bmp, .jpg en .wmf files). De file
moet in dezelfde map komen te staan waar het spel staat. full geeft aan of de
splash screen in full screen mode getoond moet worden. delay is de vertraging
(delay) in seconden voordat je terugkeert naar het spel.

show_video(fname,full,loop) Toont een splash screen met een video fragment.

fname is de naam van het video fragment (.avi of .mpg). De file moet in dezelfde
map komen te staan waar het spel staat. full geeft aan of de splash screen in full
screen mode getoond moet worden. loop geeft aan of het videofragment na een
volledige doorgang herhaald dient te worden.

show_info() Toont het formulier met daarop de spelinformatie.

Een andere categorie schermen zijn de zogenaamde popups waarin berichten, vragen,
een keuzemenu kunnen worden getoond. Een speciaal soort popup is de dialog box,
waarin een speler een getal, een zin, een kleur of een bestandsnaam kan invoeren.
Hieronder staat een overzicht van de beschikbare functies:

show_message(str) Toont een dialog box met een of andere bericht (str).
show_question(str) Toont een vraag (str). De functie retourneert de waarde
true indien de speler kiest voor yes en anders false.
show_menu(str,def) Toont een popup keuzemenu. str heeft betrekking op de
tekst uit het menu. Deze bestaat uit verschillende menu items, alle gescheiden
door een verticale streep. Bijvoorbeeld, str = 'menu0|menu1|menu2'. Indien de
keuze valt op het eerste item, retourneert de functie de waarde 0 enzovoorts.
Wordt er geen item gekozen, retourneert de functie (de standaard waarde) def.

102
 get_integer(str,def) Vraagt aan de speler in een dialoogbox om een getal. str is
het bericht. def is het standaard getal waarde van het getal.
get_string(str,def) Asks the speler in a dialog box for a string. str is the bericht.
def is the default value.
get_color(defcol) Vraagt de speler om een kleur. defcol is de standaard kleur.

get_open_filename(filter,fname) Vraagt de speler om een bestandsnaam

fname om deze te openen met de gegeven filter filter. De filter heeft de
volgende vorm: 'name1|mask1|name2|mask2|…'. Een masker bevat de
verschillende opties, gescheiden door een puntkomma. * betekent een
willekeurige string. Bijvoorbeeld: 'bitmaps|*.bmp;*.wmf'.
get_save_filename(filter,fname) Vraagt om een bestandsnaam om samen met
de filter filter te worden gesaved.
get_directory(dname) Vraagt om de directory. dname is de standaard naam.

Een speciaal soort popup is de highscore list. Deze lijst blijft bij ieder spel behouden. De
volgende functies hebben betrekking op de highscore list:

highscore_show(numb) Toont de highscore list. numb is de nieuwe score.

Indien deze score goed genoeg is voor een plaats in de high score list, kan de
speler zijn naam invoeren. Gebruik de waarde –1 om simpelweg de huidige
highscore list te laten zien. .
highscore_clear() Maakt de highscore list leeg.
highscore_add(str,numb) Voegt een speler toe, met de naam str en score
numb, aan de highscore list. highscore_value(place) Geeft de score weer van
de persoon op plaats place (1-10). Deze functie wordt vaak gebruikt om je eigen
highscore list te tekenen.
highscore_name(place) geeft de naam weer van de persoon op plaats place
(1-10).

Geen enkele van deze pop-ups worden getoond in exclusive mode.

103
Hoofdstuk 30 GML: Files, registry, and executing
programs
In more advanced games you probably want to read data from a file that you provide
with the game. For example, you could make a file that describes at what moments
certain things should happen. Also you probably want to save information for the next
time the game is run (for example, the current room). The following functions exist for
this:

file_exists(fname) Returns whether the file with the given name exists
(true) or not (false).
file_delete(fname) Deletes the file with the given name.
file_rename(oldname,newname) Renames the file with name oldname into
newname.
file_copy(fname,newname) Copies the file fname to the newname.
file_open_read(fname) Opens the indicated file for reading.
file_open_write(fname) Opens the indicated file for writing, creating it if it
does not exist.
file_close() Closes the current file (don’t forget to call this!).
file_write_string(str) Writes the string to the currently open file.
file_write_real(x) Write the real value to the currently open file.
file_writeln() Write a newline character to the file.
file_read_string() Reads a string from the file and returns this string. A
string ends at the end of line.
file_read_real() Reads a real value from the file and returns this value.
file_readln() Skips the rest of the line in the file and starts at the start of the
next line.
file_eof() Returns whether we reached the end of the file.
directory_exists(dname)Returns whether the indicated directory does
exist.
directory_create(dname)Created a directory with the given name
(including the path towards it) if it does not exist.

If the player has checked secure mode in his preferences, for a number of these
routines, you are not allowed to specify a path, and only files in the application folder can
e.g. be written.

The following three read-only variables can be useful:

game_id* Unique identifier for the game. You can use this if you need a unique
file name.
working_directory* Working directory for the game. (Not including the final
backslash.)
temp_directory* Temporary directory created for the game. You can store
temporary files here. They will be removed at the end of the game.

If you want to store a small amount of information between runs of the game there is a
simpler mechanism than using a file. You can use the registry. The registry is a large

104
database that Windows maintains to keep track of all sorts of settings for programs. An
entry has a name, and a value. You can use both string and real values. The following
functions exist:

registry_write_string(name,str) Creates an entry in the registry with

the given name and string value.
registry_write_real(name,x) Creates an entry in the registry with the
given name and real value.
registry_read_string(name) Returns the string that the given name holds.
(The name must exist. otherwise an empty string is returned.)
registry_read_real(name) Returns the real that the given name holds.
(The name must exist. Otherwise the number 0 is returned.)
registry_exists(name) Returns whether the given name exists.

Actually, values in the registry are grouped into keys. The above routines all work on
values within the key that is especially created for your game. Your program can use this
to obtain certain information about the system the game is running on. You can also
read values in other keys, but you are not allowed to write them because this easily
destroys the system. Note that keys are again placed in groups. The following routines
only work on the group HKEY_CURRENT_USER. So, for example, if you want to find
out the current temp dir, use

path = registry_read_string_ext('/Environment','TEMP');

The following functions exist.

registry_read_string_ext(key,name) Returns the string that the given

name in the indicated key holds. (The name must exist. otherwise an empty
string is returned.)
registry_read_real_ext(key,name) Returns the real that the given name
in the indicated key holds. (The name must exist. Otherwise the number 0 is
returned.)
registry_exists_ext(key,name) Returns whether the given name exists
in the given key.

Game Maker also has the possibility to start external programs. There are two functions
available for this: execute_program and execute_shell. The function execute_program
starts a program, possibly with some arguments. It can wait for the program to finish
(pausing the game) or continue the game. The function execute_shell opens a file. This
can be any file for which some association is defined, e.g. an html-file, a word file, etc.
Or it can be a program. It cannot wait for completion so the game will continue.
execute_program(prog,arg,wait) Execute program prog with arguments
arg. wait indicates whether to wait for finishing.
execute_shell(prog,arg) Executes the program (or file) in the shell.

Both functions will not work if the player set the secure mode in the preferences. You
can check this using the read-only variable:

secure_mode* Whether the game is running in secure mode.

105
Hoofdstuk 31 GML: Multiplayer spellen
Spelen tegen de computer is leuk. Maar het is veel leuker om tegen elkaar te spelen.
Het is relatief vrij eenvoudig om dergelijke spelletjes (multiplayer games) te maken. Het
is veel ingewikkelder om als tegenstander de computer te implementeren. Je begeeft je
dan namelijk op het gebied van AI (Artificial Intelligence).
Het is mogelijk om twee spelers achter dezelfde computer tegen elkaar te laten spelen.
Iedere speler krijgt bijvoorbeeld een bepaalde toetsencombinatie toegewezen. Dit wordt
in het spel geïmplementeerd. Het is echter interessanter indiende spelers ieder een
eigen computer tot hun beschikking hebben.
Beter nog: je tegenstander bevindt zich aan de andere kant van de oceaan. Game
Maker ondersteunt de zogenaamde multiplayer mode. Het maken van indrukwekkende
multiplayer games is lastig. Vooral het synchroniseren van de verschillende computers is
een moeilijke taak. Dit hoofdstuk geeft een korte uiteenzetting. Kijk op onze website voor
een uitgebreidere tutorial.

31.1 Een verbinding tot stand brengen

Om twee computers met elkaar te laten communiceren moet er een of andere
communicatie protocol worden gebruikt. Net zoals in de meeste spellen, biedt Game
Maker de mogelijkheid om uit vier verschillende verbindingstypen te kiezen, namelijk
IPX, TCP/IP, Modem en Serial.

De IPX verbinding (dit is een protocol) werkt bijna geheel transparant. Dit protocol kan
worden gebruikt indien spelers zich op dezelfde local area network bevinden (LAN). Dit
protocol dient te worden geïnstalleerd op je computer. (Lukt dit niet: raadpleeg de
Windows documentatie of ga naar het item Netwerk en voeg het
IPX protocol toe)

TCP/IP is het internet protocol. Dit protocol wordt toegepast indien je een spel met
anderen speelt op het internet, onder de aanname dat je hun IP adressen weet. Op een
lokaal netwerk kun je het protocol toepassen zonder gebruik te maken van adressen.
Een modem verbinding wordt tot stand gebracht via een modem. Je moet daarvoor een
aantal instellingen veranderen (een variabele dat gebruik voor initialisatie (van het type
string) en een telefoonnummer).
En tot slot kun je een serial line verbinding (een directe verbinding tussen de computers)
tot stand worden gebracht. De instellingen van de diverse poorten is daarvoor van
belang.

Er zijn vier functies beschikbaar om de verbindingen te initialiseren(dat wil zeggen. tot

stand brengen);

mplay_init_ipx()initialiseert een IPX verbinding

mplay_init_tcpip(addr) initialiseert een TCP/IP verbinding. addr is een
stringvariabele die het internet adres of IP adres bevat , bijvoorbeeld.
'www.gameplay.com' of '123.123.123.12', mogelijk gevolg door een poortnummer
(bijvoorbeeld. ':12'). Indien je deelneemt aan een sessie (zie hieronder) moet het
adres ingevuld worden. Dit is niet verplicht op een LAN.
mplay_init_modem(initstr,phonenr) initialiseert een modem verbinding. initstr is de

106
 initialisatie string van de modem (kan leeg zijn). phonenr is een stringvariabele die
het telefoonnummer bevat, bijvoorbeeld '0201234567'. Indien je deelneemt aan een
sessie (zie.....) moet het telefoonnummer worden ingevuld.
mplay_init_serial(portno,baudrate,stopbits,parity,flow) initialiseert een serial line
verbinding portno is het poort nummer (1-4). baudrate staat voor de baudrate (100-
256 K). stopbits is het aantal stopbits (0 = 1 bit, 1 = 1.5 bit, 2 = 2 bits).
parity is de pariteit (0=geen, 1=oneven pariteit, 2=even pariteit, 3=mark.
En flow staat voor flow control (0=none, 1=xon/xoff, 2=rts, 3=dtr, 4=rts and dtr).
Deze functie geeft een bericht indien de initialisatie succesvol is verlopen. Hieronder
staat een voorbeeld van een dergelijke initialisatie:
mplay_init_serial(1,57600,0,0,4). Geef een 0 als eerste argument om een
dialoogvenster te openen om de settings te wijzigen.

Wil je gebruik maken van deze functies moet je (afhankelijk van je keuze) deze in het
spel precies één keer aanroepen. Alle functies geven in ieder geval bericht indien de
initialisatie succesvol is verlopen . Geen succes betekent dat de desbetreffende protocol
niet op je computer is geïnstalleerd of niet door je computer wordt ondersteund. Om na
te gaan of er een juiste verbinding tot stand is gekomen, kun je de volgende functies
gebruiken:

mplay_connect_status() geeft de status van de huidige verbinding. 0 = geen

verbinding, 1 = IPX verbinding, 2 = TCP/IP verbinding, 3 = modem verbinding, and 4
= serial line verbinding.

Om de verbinding te beëindigen:

mplay_end()beëindigt de huidige verbinding .

31.2 Het maken en deelnemen aan sessies

Als je eenmaal aangesloten bent op een netwerk, kunnen er meerdere spellen op dat
netwerk worden gespeeld. We noemen dit sessies.
De verschillende sessies kunnen betrekking hebben op hetzelfde spel of op
verschillende spellen.
Indien je een spel wilt spelen op een netwerk moet deze een unieke identificatie krijgen.
Game Maker doet dit bijna vanzelf. Je moet je wel goed realiseren dat indien je de id
van het spel verandert vanuit de opties in Game Maker de identificatie ook veranderd.
Door de id van het spel te veranderen kun je voorkomen dat een speler met een oudere
versie kan spelen tegen een andere met een nieuwere versie.

Als je een nieuwe multiplayer game wilt starten, moet je een nieuwe sessie aanmaken.
Om dit voor elkaar te krijgen kun je de volgende routine volgen:

mplay_session_create(sesname,playnumb,playername)maakt een nieuwe

sessie met de huidige verbinding die je hebt gekozen. sesname is een string
variabele welke de naam van de sessie aanduidt. playnumb is het getal dat het
maximaal aantal spelers die aan het spel mogen deelnamen aanduidt ( 0 voor
een willekeurig aantal). playername is de spelernaam. Deze naam wordt
geretourneerd indien de nieuwe sessie succesvol is aangemaakt.

107
Een instantie (een speler) van het spel maakt de sessie aan. De andere instanties
(spelers) kunnen sessie delen. Dit laatste is ingewikkelder. Je zult eerst moeten nagaan
welke sessies nog beschikbaar zijn en daaruit een keuze maken. Er zijn belangrijke drie
routines die dit mogelijk maken:

mplay_session_find()zoekt naar alle sessies die nog spelers accepteren en geeft

dit aantal weer.
mplay_session_name(numb)geeft de naam van de sessie met nummer numb (0
is de eerste sessie). Deze routine kun je alleen maar aanroepen indien de vorige
functie reeds is aangeroepen
mplay_session_join(numb,playername)zorgt ervoor dat je kunt deelnemen aan
sessie met nummer numb (0 is de eerste sessie). playername is de naam van de
desbetreffende speler. Deze wordt geretourneerd indien je inderdaad aan deze
sessie mag deelnemen.

Er is nog een routine die de mode van de sessie kan veranderen. Deze dient te worden
aangeroepen voordat je een nieuwe sessie aanmaakt:

mplay_session_mode(move) Indien de host (computer) waarop de sessie wordt

gespeeld wordt afgesloten kan de sessie worden verder gespeeld door te
veranderen van host.Zo niet: dan beëindigt de sessie. move heeft als waarde
true of false (de standaard instelling).

Om de status na te gaan van de huidige sessie gebruik je:

mplay_session_status()geeft de status van de huidige sessie . 0 = geen sessie,

1 = maak een nieuwe sessie aan, 2 = gedeelde sessie.

Het stoppen van een sessie:

mplay_session_end()stopt de sessie van de speler.

31.3 Spelers
Iedere instantie van het spel dat deelneemt aan een sessie is een speler. Zoals
hierboven al is aangegeven heeft iedere speler een naam. Er zijn drie routines die
betrekking hebben op spelers:

mplay_player_find()zoekt naar alle spelers in de huidige sessie en geeft dit

aantal weer.
mplay_player_name(numb) geeft de naam van de speler met nummer numb (0
is de eerste speler, dit ben jezelf). Deze routine of functie kun je alleen maar
aanroepen indien de vorige functie reeds is aangeroepen.
mplay_player_id(numb)geeft de unieke id van spelernummer numb (0 is de
eerste speler, dit ben jezelf). Deze routine kun je alleen maar aanroepen indien
de eerste functie reeds is aangeroepen.
Deze id wordt gebruikt bij het verzenden van berichten en ontvangen van
berichten naar de individuele spelers.

108
31.4 Shared data
Shared data communication is waarschijnlijk de gemakkelijkste manier om een spel te
synchroniseren.
Er is een verzameling van 10.000 waarden waarvan alle entiteiten, die behoren tot het
spel, gebruik kunnen maken. Iedere entiteit kan waarden geven en lezen. Game Maker
zorgt er zelf voor dat iedere entiteit dezelfde waarden ziet.
Een waarde kan van het type real of string zijn. Er zijn slechts twee functies:

mplay_data_write(ind,val)write value val (string or real) into location ind (ind

tussen 0 en 10000 inclusief de grenzen).
mplay_data_read(ind) geeft de waarde in locatie location ind (ind tussen 0 en
10000 inclusief de grenzen). Oorspronkelijk hebben allen de waarde 0.

Om data op de verschillende machines met elkaar te synchroniseren, kun je gebruik

maken van een guaranteed mode. Deze mode zorg ervoor dat iedere verandering van
de data ook op de andere machines terecht komt (dit is echter traag). Je kunt tevens
gebruik maken van de non-guaranteed mode. Om de mode te veranderen kun je de
volgende functie gebruiken:

mplay_data_mode(guar)geeft aan welke mode je wel of niet wilt gebruiken.

guar heeft de waarde true (de standaard waarde) of false.

31.5 Berichten
Het tweede communicatie middel dat door Game Maker wordt ondersteund is het
verzenden of ontvangen van berichten. Een speler heeft de mogelijkheid om berichten te
sturen gericht aan een of meerdere spelers. Spelers kunnen zien of berichten zijn
aangekomen en naar aanleiding daarvan de juiste actie ondernemen. Berichten kunnen
verstuurd worden in guaranteed mode. Ze weten dan zeker dat ze aankomen, maar dit
duurt wat langer. Daarnaast kunnen ze ook in non-guaranteed mode worden verstuurd,
Dit laatste is sneller. Alleen is er geen zekerheid dat ze aankomen.

Als het gaat om berichten kunnen de volgende routines worden gebruikt:

mplay_message_send(player,id,val)zendt een bericht naar de speler in kwestie

(maak gebruik van een identifier, om de speler mee te identificeren. Dit kan een
nummer zijn of simpelweg de naam van de speler; gebruik 0 om het bericht naar
alle spelers te versturen). id is de identifier van het bericht van het type (integer)
en val is de waarde (van het type real of string). Het bericht wordt verzonden in
non-guaranteed mode.
mplay_message_send_guaranteed(player,id,val) zendt een bericht naar de
speler in kwestie (maak gebruik van een identifier, om de speler mee te
identificeren. Dit kan een nummer zijn of simpelweg de naam van de speler;
gebruik 0 om het bericht naar alle spelers te versturen). id is de identifier van het
bericht van het type (integer) enval is de waarde (van het type real of string). Het
bericht wordt verzonden in guaranteed mode.
mplay_message_receive(player) ontvangt het volgende bericht uit de wachtrij
van berichten, afkomstig van de desbetreffende speler (naam of id). Gebruik 0
voor berichten van iedere willekeurige speler. Deze functies geeft een melding

109
 als er inderdaad een nieuw bericht is gearriveerd. Om de inhoud te kunnen lezen
gebruik je de volgende functies:
mplay_message_id() Geeft de identifier van de laatste (nieuwste) ontvangen
bericht. mplay_message_value() Geeft de waarde van het laatste (nieuwste)
ontvangen bericht.
mplay_message_player() geeft de speler die het laatst (nieuwste) bericht heeft
verstuurd. mplay_message_name() Geeft de naam van de speler die het laatste
ontvangen bericht heeft verstuurd.
mplay_message_count(player) Geeft het aantal berichten weer die zich nog in
de wachtrij bevinden. (gebruik 0 om alle berichten te tellen).
mplay_message_clear(player) Verwijdert alle berichten die zich nog in wachtrij
bevinden. (gebruik 0 om alle berichten te verwijderen).

Een aantal opmerkingen zijn hier op zijn plaats. Ten eerste, indien je een bericht wilt
versturen naar slechts één speler moet je de unieke id van de desbetreffende speler
weten. Je kunt dit te weten komen door gebruik te maken van de functie
mplay_player_id(). (zie hierboven)

Deze identifier wordt tevens gebruikt bij het ontvangen van berichten van een specifieke
speler. Je kunt de naam gebruiken van de spelers. Indien meerdere spelers dezelfde
naam hebben, krijgt slechts de eerste het bericht.

110
Hoofdstuk 32 GML: Het gebruik van DLL's
In de gevallen waar zelfs de functionaliteit van GML te kort schiet, kun je de
mogelijkheden uitbreiden door gebruik te maken van plug-ins. Een plug-in verschijnt in
de vorm van een DLL- file (Dynamic Link Library). In zo’n file is het mogelijk
(uitgebreidere) functies te definiëren.
Deze functies kunnen in iedere programmeertaal wordt gemaakt, zolang deze talen
maar DLL’s ondersteunen (bijvoorbeeld Delphi, Visual C++, Visual Basic, enz) .

Om zelf functies te kunnen schrijven is er wel enige programmeer ervaring nodig.

De Plug-in functies moeten voldoen aan een specifieke format:

De functies kunnen geen, één of twee argumenten bevatten. Deze

argumenten kunnen van het type real of string zijn (niet lege string). Ze
moeten als resultaat een real of string terug geven

In de taal Delphi kun je een DLL als volgt maken: Kies uit het FILE menu de optie NEW
en daarna DLL. Hieronder staat een voorbeeld van een DLL gemaakt in de taal Delphi.
De DLL zou je in Game Maker kunnen gebruiken. (let op: dit is Delphi code en geen
GML code!)

library MyDLL;

uses SysUtils, Classes;

function MyMin(x,y:real):real; 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 heeft twee argumenten van het type real. Het resultaat van de bewerking wordt
opgeslagen in de variabele Result. Deze bepaalt het minimum van de argumenten.

DoubleString verdubbelt de string. Let er even op dat de variabele Result in deze functie
een globale variabele is. Verder is gebruik gemaakt van cdecl. Dit is verplicht. Heb je
eenmaal de functies gemaakt in Delphi, sla je deze op als MyDLL.DLL (is een slechts

111
een voorbeeldnaam). Zet deze file in de juiste directory (daar waar het spel uitgevoerd
wordt!!!).

Om bovenstaande DLL in Game Maker te kunnen gebruiken, moet je eerst die twee
externe functies specificeren (aanmelden), waarbij tevens het type van de argumenten
moet worden gegeven.
Daarvoor kun je de volgende functies in GML gebruiken:

external_define0(dll,name,restype) Definieert een externe functie zonder

argumenten.. dll is de naam van de DLL file. name is de naam van de
desbetreffende functie. En restype is het type van het resultaat. Je hebt de keuze
uit twee typen: ty_real of ty_string.
external_define1(dll,name,arg1type,restype) Definieert een externe functie
met één argument. arg1type is het type van de argument. Er is wederom de
keuze uit ty_real of ty_string indien het gaat om het teruggeven resultaat.
external_define2(dll,name,arg1type,arg2type,restype) Definieert een externe
functie met twee argumenten
external_define3(dll,name,arg1type,arg2type,arg3type,restype) Definieert
een externe functie met drie argumenten
external_define4(dll,name,arg1type,arg2type,arg3type,arg4type,restype)
Definieert een externe functie met vier argumenten

Elk van bovenstaande functies geeft de id van de externe functie weer. De id wordt
gebruikt om de desbetreffende functie aan te roepen. In bovenstaande voorbeeld wordt
aan het begin van het spel de volgende GML code gebruikt:
{
global.mmm =
external_define2('MYOWN.DLL','MyMin',ty_real,ty_real,ty_real);
global.ddd =
external_define1('MYOWN.DLL',DoubleString,ty_string,ty_string);
}

Indien je de externe functies wilt aanroepen, gebruik je bijvoorbeeld de GML code:

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

Hieronder staan de aanroep functies::

external_call0(id) Roept de externe functie, zonder parameters, aan met behulp

van de toegekende id.
external_call1(id,arg1) Roept de externe functie, met één parameter, aan met
behulp van de toegekende id.
external_call2(id,arg1,arg2) Roept de externe functie, met twee argumenten,
aan met behulp van de toegekende id.
external_call3(id,arg1,arg2,arg3) Roept de externe functie, met drie
argumenten, aan met behulp van de toegekende id.
external_call4(id,arg1,arg2,arg3,arg4) Roept de externe functie, met vier
argumenten, aan met behulp van de toegekende id.

112
Misschien vraag je je het volgende af: Hoe maak je nu een functie in een DLL file die
werkelijk iets doet in het spel.
Voorbeeld: Je wilt een DLL file maken met een functie die instanties van de objecten in
jou spel toevoegt. De gemakkelijkste manier om dit voor elkaar te krijgen is door ervoor
te zorgen dat jouw DLL functie een string als resultaat teruggeeft met daarin een stuk
GML code. Deze string kan met de volgende GML functie uitgevoerd worden;

execute_string(str) Voert de code in de string str uit.

Nu is het mogelijk om een externe functie aan te roepen en de desbetreffende string uit
te voeren:
{
ccc = external_call2(global.mmm,x,y);
execute_string(ccc);
}

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

Het gebruik van DLL’s is een krachtige manier om de functionaliteit van het spel uit te
breiden. Pas dit alleen toe indien je er goed mee overweg kunt. En anders laat dit
achterwege.

113