interceptors GML Lernprojekt

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • interceptors GML Lernprojekt

      Dies ist ein Game Maker Tutorial für Anfänger, die sich nicht lange mit Drag&Drop aufhalten wollen, sondern sofort mit der Scriptsprache GML arbeiten wollen. Anhand eines simplen Lernprojektes werden die nötigen Grundlagen vermittelt.

      1. Game Maker: Überblick

      Der Game Maker ist eine Entwicklungsumgebung für PC-Spiele, was bedeutet, dass viele für Spiele relevante Funktionen bereits vorgefertigt zur Verfügung stehen. Neben Ressourcenverwaltung (Sprites, Sounds, Backgrounds/Tiles, Fonts, Paths, Scripts, Time lines, Objects und Rooms) bietet er Funktionen für Sound-/Musikwiedergabe, Grafikdarstellung, Partikeleffekte, Bewegung, Kollision, Wegfindung, Benutzereingabe, Speichern/Laden, Multiplayer, ini-Dateien sowie die Möglichkeit zusätzliche Funktionalität über dll Dateien einzubinden. Obwohl der Game Maker auf Direct3D aufbaut und auch nützliche 3D-Funktionen bietet, ist er primär für 2-dimensionale Spiele ausgelegt. Außerdem enthält er ein simples Grafikprogramm und einen Leveleditor.

      1.1 Objects

      Der Game Maker ist ein objektorientiertes Programm. Es können beliebige Objects definiert werden, deren Aussehen über lokale Variablen festgelegt wird. Von jedem Object können in den einzelnen Rooms (die Level des Spiels) Instanzen platziert werden. Ein Instanz besitzt zu Beginn alle Eigenschaften des Objects, die sich jedoch durch Interaktion mit dem Spieler oder anderen Spielelementen lokal für diese Instanz ändern können. Die wichtigsten Einstellungen sind das Sprite mit dem das Object im Spiel gezeichnet werden soll, die Maske für die Kollision, der Depth-Wert, der die Position in der Zeichenreihenfolge angibt (je niedriger die depth, desto weiter im Vordergrund befindet sich das Object) und das Parent Object, über das Vererbung ermöglicht wird.

      1.2 Events

      Die komplette Spiellogik des Game Makers basiert auf einem Ursache-Wirkungs-Prinzip, was bedeutet, dass sämtliche Aktionen des Spiels jeweils Reaktionen auf bestimmte Ereignisse in der Spielwelt sind. Für jedes Object können deshalb Events definiert werden, die als Auslöser für so genannte Actions dienen. Jedes Event wird zur Laufzeit des Spiels in jedem Step (Der Game Maker läuft standardmäßig mit 30 Steps pro Sekunde) abgefragt und je nach Ergebnis dieser Überprüfung werden die korrespondierenden Actions gestartet oder nicht.
      Die Reihenfolge der Abfrage sieht folgendermaßen aus:
      • Begin Step
      • Alarm 0-11
      • Keyboard and Mouse
      • Keyboard and Mouse Press
      • Keyboard and Mouse Release
      • Step
      • End of Path
      • Outside Room
      • Intersect Boundary
      • Collision
      • End Step
      • Draw
      • Animation End

      Die Events Begin Step, Step und End Step treten immer ein. Actions, die für diese Events definiert wurden, werden folglich jeden Step ausgeführt und verschlingen daher viel Prozessorleistung. Die genaue Bedeutung der einzelnen Events kann in der umfangreichen Hilfe nachgelesen werden, die vom deutschen Game Maker Forum gm-d.de auch in die deutsche Sprache übersetzt wurde.

      1.3 Actions

      Durch einfaches Drag&Drop können Actions (jeweils repräsentiert durch ein Icon) aus einem seitlichen Menü ausgewählt und einem Event zugewiesen werden. Die vorgegebenen Actions sind in verschiedene Bereiche gegliedert und beinhalten unter anderem Funktionen zur Bewegung von Instanzen, Änderung der Sprites, Abspielen von Sounds und Wechseln des Rooms. Die beiden mächtigsten Actions sind jedoch Execute a piece of code und Execute a script, die sich beide im Tab control befinden, da sie es ermöglichen eigenen Code in der internen Scriptsprache des Game Makers (GML) zu schreiben.

      1.4 Game Maker Language

      Die interne Scriptsprache Game Maker Language (GML) erlaubt den Zugriff auf alle Funktionen und Variablen des Game Makers und ist relativ leicht zu erlernen. Die Syntax orientiert sich an höheren Programmiersprachen, wie C, Pascal oder Java, bietet jedoch enorm viele Freiheiten (zum Beispiel sind Semikolons freiwillig und können auch weggelassen werden). GML beherrscht dynamische Typisierung, d.h. je nach Zuweisung ändert sich der Datentyp einer Variable. Der Game Maker arbeitet intern mit Fließkommazahlen und Strings. Logische Operationen werden ebenfalls mit Fließkommazahlen ausgeführt, die Zahl 1 entspricht dabei true, 0 entspricht false.
      Beispiel:

      GML-Quellcode

      1. a = 0;
      2. a = !a; // 0 entspricht false -> a = !false -> a = true
      3. b = true;
      4. if (a && b) { // b == true -> a && b == true
      5. b = “a und b sind true!“;
      6. draw_text(a,100,b); // zeichnet den String b an die Stelle 1,100
      7. }

      Diese Vereinfachung bringt jedoch den Nachteil mit sich, dass viel Speicherplatz verschwendet wird, da jede Variable, egal ob sie nur einen ganzzahligen oder bool‘schen Wert enthält, immer den Speicherplatz einer Fließkommazahl benötigt.

      2. Ein Lernprojekt

      Am besten erklären und lernen kann man die Funktionen des Game Makers anhand eines Lernprojektes. Dieses Projekt ist ein kleines Geschicklichkeitsspiel und soll zeigen, mit wie wenig Aufwand ein einfaches Spiel im Game Maker erzeugt werden kann. Das Designdokument, das am Anfang jeder Spieleentwicklung steht, fällt in diesem Fall sehr knapp aus:

      Spielidee: Im inneren eines menschlichen Körpers werden Zellorganellen von Viren angegriffen. Der Spieler muss die Viren mit einem Präzisionslaser vernichten.

      Spielablauf: Anfangs befinden sich 10 Zellorganellen in der Mitte des Bildschirms. Außerhalb des Bildschirms erscheinen zufällig Viren, die sich auf das nächstliegende Organell zubewegen, um es anzugreifen. Der Spieler kann die Viren zerstören und erhält für jedes zerstörte Virus 10 Punkte. Je mehr Punkte der Spieler hat, desto stärker und zahlreicher werden die Viren, so dass der Spieler irgendwann keine Chance mehr hat, die Organellen zu beschützen. Haben die Viren alle Organellen zerstört, ist das Spiel vorbei und der Spieler kann sich in die Highscoreliste eintragen.

      Steuerung: Das Spiel wird mit der Maus gesteuert, die durch ein Fadenkreuz auf dem Bildschirm repräsentiert wird. Durch Klicken der linken Maustaste wird der Laser abgefeuert. Die Taste Escape beendet das Spiel. Durch Drücken von F4 kann zwischen Fenster- und Vollbildmodus gewechselt werden.

      Grafik: Das Spiel startet in einem Fenster mit einer Auflösung von 800x600 Pixeln. Für das Spiel werden vier Grafiken benötigt. Ein Hintergrundbild (800x600), ein Virus (ca. 64x64) , ein Organell (ca. 64x64) und ein Fadenkreuz (ca. 32x32).

      Sound: Für die Vertonung des Spiels werden Sounds für folgende Aktionen benötigt: Laserschuss, Lasertreffer, Verletzung. Ferner wird im Hintergrund ein Musikstück im MIDI-Format erklingen.


      Um dieses Beispiel nachzuvollziehen, benötigen Sie eine unregistrierte Version des Game Makers 7 von yoyogames.com/gamemaker/try.
      Installieren und starten Sie das Programm. Damit wir Scripts verwenden können, muss der Game Maker im Advanced Mode laufen. Falls das nicht der Fall ist, muss im Menü File der Menüpunkt Advanced Mode angeklickt werden.
      Die Benutzeroberfläche des Game Makers ist sehr einfach gehalten: Oben befindet sich ein Windows-übliches Menü, gefolgt von einer Symbolleiste, die häufig benötigte Befehle, wie Funktionen zum Erstellen neuer Ressourcen oder zum Starten des Spiels enthält. Das Hauptfenster besteht aus dem Arbeitsbereich und dem Ressourcen-Explorer. Im Ressourcen-Explorer werden alle Grafiken, Sounds, Objekte und Räume angelegt, die das Spiel benutzen wird.

      Achtung: Ich verwende einen Befehl, der mit der unregistrierten Version des Game Makers 7 nicht funktioniert. Es handelt sich um effect_create_above(...). Falls Sie nicht im Besitz der registrierten Version sind, müssen Sie die Zeilen mit diesem Befehl weglassen (oder mit zwei vorangestellten Schrägstrichen // auskommentieren).

      2.1 Sprites

      Sprites sind die Grafiken, die später benutzt werden, um die Spielobjekte auf den Bildschirm zu zeichnen. Sprites bieten außerdem die Möglichkeit, einen Nullpunkt und eine Bounding Box festzulegen. Der Nullpunkt bestimmt, an welchem Punkt die Grafik bewegt, gedreht und skaliert wird (die gebräuchlichsten Positionen eines Nullpunkts sind Links-Oben oder Mitte). Die Bounding Box wird für die Berechnung der Kollisionen zwischen den Objekten benötigt. Es besteht allerdings auch die Möglichkeit über die Funktion Precise collision checking eine pixelgenaue Kollisionsabfrage des Sprites zu verwenden. Ein Sprite kann auch aus mehreren Bildern bestehen, um beispielsweise animierte Grafiken darzustellen.



      spr_crosshair
      Um das Sprite für das Fadenkreuz anzulegen, klicken Sie entweder auf Resources->Create Sprite im Menü, auf das rote „Pacman“-Symbol in der Symbolleiste oder mit der rechten Maustaste auf den Sprites-Ordner im Ressourcen-Explorer und wählen sie Create Sprite aus dem Popup-Menü.
      Im Arbeitsbereich öffnet sich nun ein Sprite Properties Fenster. Geben Sie unter Name spr_crosshair ein. Es ist empfehlenswert Präfixe vor die eigentlichen Namen der Ressourcen zu setzen, da der Game Maker Probleme bekommt, wenn Namen öfter als einmal auftreten und dadurch nicht mehr eindeutig sind. Setzen Sie den Nullpunkt des Sprites auf die Mitte des Sprites, indem Sie den Button mit der Aufschrift „Center“ anklicken. Mit Edit Sprite kommen wir in den Sprite Editor, der unter anderem das Anlegen von Animationen erlaubt (Über Load Sprite können auch externe Bilder geladen werden). Durch einen Doppelklick auf das momentan noch leere grüne Sprite mit der Bezeichnung image 0 gelangen wir in den Image Editor, einem simplen Grafikprogramm. Zeichnen Sie dort ein Fadenkreuz, das genau auf die Mitte des Sprites zielt. Der linke untere Pixel legt die transparente Farbe fest. Falls in den Sprite Properties die Option Transparent aktiviert ist, werden alle Pixel die diese Farbe verwenden im Spiel nicht gezeichnet. Schließen Sie nun den Image Editor, den Sprite Editor und die Sprite Properties über den grünen „Bestätigungs-Haken“.

      spr_organell
      Legen Sie nun ein zweites Sprite mit dem Namen spr_organell an und ändern Sie die Größe durch den Menüpunkt Transform->Resize Canvas auf 64x64 Pixel. Zeichnen Sie im Image Editor ein rundliches Organell in blauen Farbtönen. Zuletzt sollten Sie auch hier den Nullpunkt zentrieren („Center“ im Sprite Properties Fenster).



      spr_virus
      Erstellen Sie noch ein letztes Sprite und nennen Sie es spr_virus. Setzen Sie die Maße ebenfalls auf 64x64 und zeichnen Sie ein rotes stacheliges Virus. Damit das Virus noch gefährlicher wirkt, sollte es animiert werden. Wählen Sie im Sprite Editor das fertige Bild image 0 aus und kopieren Sie es über Edit->Copy (STRG+C). Mit Edit->Paste (STRG+V) können Sie nun mehrere Frames hinzufügen. Verändern Sie das Bild jedesmal ein bisschen und überprüfen Sie die Animation im Sprite Editor, indem Sie links Show Preview aktivieren. Sie sollten in den Sprite Properties die Option Precice collision checking deaktivieren, da sonst Probleme mit der Kollisionsabfrage entstehen können. Sie können die Boundingbox verkleinern, so dass es nachher aussieht, als würden die Viren ein wenig in die Organellen eindringen.

      2.2 Backgrounds

      Der Game Maker macht eine Unterscheidung zwischen Grafiken, die einem Object zugewiesen werden (Sprites), und Grafiken, die einem Room zugewiesen werden (Backgrounds). Backgrounds sind nicht animiert, können dafür jedoch ohne großen Rechenaufwand automatisch wiederholt werden, falls die Grafik kleiner als der Bildschirm ist. Außerdem besteht die Möglichkeit Tilesets anzulegen und die Hintergründe der Rooms durch das Platzieren einzelner Kacheln (Tiles) zu gestalten.
      Erstellen Sie einen Background über den Menüpunkt Resources->Create Background und geben Sie als Name bgr_game an. Edit Background öffnet den bereits bekannten Image Editor. Ändern Sie die Größe mit Transform->Resize Canvas auf 800x600 Pixel und zeichnen Sie ein dunkles Hintergrundbild, damit sich die bereits erstellten Sprites später gut abheben.

      2.3 Objects und Scripts

      obj_organell
      Das einfachste Object ist das Organell, da es über kein eigenes Verhalten verfügt. Erstellen Sie analog zu den bisherigen Ressourcen ein neues Object mit dem Namen obj_organell und dem Sprite spr_organell. Machen Sie einen Haken bei solid, damit ein Virus bei einer Kollision nicht in das Organell eindringt. Das Organell soll nicht beim sofortigen Kontakt mit einem Virus sterben, sondern erst nach einigen Attacken. Für dieses Feature benötigen wir eine lokale Variable, die die Lebenspunkte der Instanz speichert. Klicken Sie auf Add Event und wählen Sie das Create Event aus. Am rechten Rand des Object Properties Fensters wählen Sie den Reiter control und ziehen das Icon Execute code in die Actions Spalte. Es öffnet sich ein Textfeld, in das Sie folgenden Code schreiben:

      GML-Quellcode

      1. hp=100;

      Diese Zeile deklariert die Variable hp und weist ihr den Wert 100 zu. Da der Code im Create Event steht, wird er nur einmal pro Instanz des Typs obj_organell ausgeführt.



      obj_virus
      Das Virus wird das wichtigste Object in unserem Spiel. Es muss sich über den Bildschirm bewegen, selbstständig Organellen angreifen und selbst verwundbar gegenüber Mausklicks sein. Wir benötigen also Events für Kollisionen und Mausklicks, sowie eine künstliche Intelligenz, die die Bewegung steuert. Die Bewegung werden wir über ein Alarm Event lösen, das nur alle paar Ticks aufgerufen wird und dann ein neues Ziel festlegt. Um den Code übersichtlich zu halten, erstellen wir für das Virus eigene Scripts, die wir dann bequem über den Ressourcen-Explorer bearbeiten können. Legen Sie also folgende Scripts an (Resources->Add Script), die vorerst noch leer bleiben: scr_virus_create, scr_virus_alarm, scr_virus_hit und scr_virus_attack.
      Erstellen Sie nun ein neues Object, nennen Sie es obj_virus und weisen ihm das Sprite spr_virus zu. Jetzt können wir die verschiedenen Events erstellen und ihnen jeweils das passende Script zuweisen (Das Execute Script Icon befindet sich neben Execute Code im control Tab).
      Weisen sie dem Create Event das scr_virus_create Script zu, dem Alarm Event „alarm 0“ das scr_virus_alarm Script, dem Mouse Event „Left Pressed“ das scr_virus_hit Script und dem Collision Event „obj_organell“ das scr_virus_attack Script.
      Erstellen Sie noch das Event Collision Event „obj_virus“ und wählen Sie die Action Bounce aus dem move Tab. Geben Sie bei precise „not precise“ und bei against „all objects“ ein. Sollten nun zwei Viren aufeinandertreffen, dann werden diese voneinander abprallen.

      Schließen Sie die Object Properties und bearbeiten Sie die Scripts:

      scr_virus_create:

      GML-Quellcode

      1. hp=5+random(score/50);
      2. scr_virus_alarm();
      3. if (place_meeting(x,y,obj_virus)) instance_destroy();
      4. image_speed=0.5;

      Das Virus wird also ebenfalls Lebenspunkte besitzen, nur diesmal ist der Startwert abhängig von der aktuellen Punktzahl des Spielers. score ist eine globale Variable, die der Game Maker vorgibt. Sie kann von jedem Object aus abgefragt und verändert werden. Die Funktion random(x) liefert einen zufälligen Wert zwischen 0 und x. In der zweiten Zeile wird das Script scr_virus_alarm manuell aufgerufen, damit sich das Virus gleich von Beginn an einen Weg sucht. Die dritte Zeile überprüft, ob es an der Stelle, an der sich das Virus gerade befindet schon ein anderes Virus befindet und entfernt sich selbst, falls dies der Fall ist. Damit soll verhindert werden, dass zufällig erscheinende Viren, aufeinander platziert werden, was durch die Bounce Action sonst Probleme bereiten würde. Die letzte Zeile verlangsamt die Animation, die sonst viel zu schnell ablaufen würde. Eine image_speed von 1 würde bedeuten, dass jeden Step das Bild gewechselt wird, der Wert 0.5 erreicht, dass dies nur noch alle zwei Steps passiert, so dass sich die Geschwindigkeit der Animation halbiert.

      scr_virus_alarm:

      GML-Quellcode

      1. target=instance_nearest(x,y,obj_organell);
      2. if (target!=noone){
      3. direction=point_direction(x,y,target.x,target.y);
      4. if (random(4)<1) direction=random(360);
      5. speed=6;
      6. alarm[0]=10+random(10);
      7. }

      Das Script scr_virus_alarm sorgt dafür, dass das Virus sich ein Ziel sucht und sich darauf zubewegt. In der ersten Zeile wird eine Referenz auf die nächstliegende Instanz vom Typ obj_organell in der lokalen Variable target gespeichert. Die Funktion instance_nearest(x,y,obj) liefert den Wert noone, falls keine Instant obj_organell existiert. Die if-Abfrage in der zweiten Zeile stellt sicher, dass der Code in der Klammer nur ausgeführt wird, wenn die Variable target nicht den Wert noone erhalten hat. direction ist eine lokale Variable und gibt die Richtung der Bewegung der Instanz wieder. Die Funktion point_direction(x1,y1,x2,y2) liefert den Winkel zwischen einer Geraden durch die Punkte (x1,y1) und (x2,y2) und der x-Achse. Die vierte Zeile sorgt also dafür, dass das Virus sein Ziel anvisiert. Um die Bewegung etwas weniger vorhersehbar zu machen, setzt die folgende Zeile mit 25% Wahrscheinlichkeit die Richtung wieder auf einen Zufallswinkel. Die lokale Variable speed sorgt schließlich dafür dass sich die Instanz auch wirklich bewegt. Der Wert 6 bedeutet, dass sich das Virus fortan jeden Step um 6 Pixel in die Richtung direction verschiebt. Die letzte Zeile des Blocks setzt den Wert von Alarm 0 wieder auf einen Wert zwischen 10 und 20 Steps. Nach Ablauf dieser Anzahl von Steps wird das Script erneut aufgerufen.

      scr_virus_hit:

      GML-Quellcode

      1. effect_create_above(ef_ring,mouse_x,mouse_y,3,c_red); // nur in GM 7.0 Pro
      2. hp-=10;
      3. if (hp<0){
      4. score+=10;
      5. effect_create_above(ef_explosion,x,y,4,c_red); // nur in GM 7.0 Pro
      6. instance_destroy();
      7. }

      Dieses Script wird immer dann ausgeführt, wenn der Spieler das Virus mit der Maus anklickt, es also mit dem Laser unter Beschuss nimmt. Wir nutzen hier die Effektengine des Game Makers, die nicht sonderlich umfangreich ist. Wesentlich eindrucksvoller ist es, wenn man eigene Effekte programmiert, aber für unser Lernprojekt reicht dieser Effekt vollkommen aus. Mit der Funktion effect_create_above(effect,x,y,size,color) erstellen wir in der ersten Zeile einen roten Ring-Effekt, der einen Treffer signalisieren soll. In der zweiten Zeile wird die lokale Variable hp um 10 verringert. Sinkt hp unter 0, dann hat der Spieler das Virus zerstört. Die globale Variable score wird erhöht, ein Explosionseffekt erzeugt und das Virus mit instance_destroy() aus dem Spiel entfernt.

      scr_virus_attack:

      GML-Quellcode

      1. speed=0;
      2. other.hp-=10;
      3. if (other.hp<=0){
      4. effect_create_above(ef_explosion,other.x,other.y,2,c_blue); // nur in GM 7.0 Pro
      5. with (other) instance_destroy();
      6. if (instance_number(obj_organell)==0){
      7. highscore_show(score);
      8. score=0;
      9. room_restart();
      10. }
      11. scr_virus_alarm();
      12. }
      13. effect_create_above(ef_ring,(x+other.x)/2,(y+other.y)/2,1,c_blue); // nur in GM 7.0 Pro
      14. alarm[0]=10+random(10);
      Alles anzeigen

      Wenn ein Virus mit einem Organell kollidiert, dann startet dieses Script. Innerhalb eines Kollisionsevents enthält die lokale Variable other eine Referenz auf die Instanz, mit der die Kollision stattfand. Deshalb wird in der zweiten Zeile, die Variable hp des Organells verringert. Gleich danach wird abgefragt, ob das Organell durch diesen Angriff zerstört wurde. Falls ja, wird ein Explosionseffekt erstellt (diesmal in blau) und das Organell entfernt. Die with-Konstruktion bewirkt, dass sich die nachfolgende Anweisung auf die Instanz in der Klammer bezieht, in diesem Fall auf das Organell (other), das die Kollision ausgelöst hat.
      Nun wird zusätzlich noch überprüft, ob es sich bei der zerstörten Instanz um die letzte ihrer Art gehandelt hat. Wenn nämlich alle Organellen zerstört sind, dann endet das Spiel. Durch die Funktion highscore_show(score) wird dann der aktuelle Punktestand mit den Einträgen einer Highscoreliste verglichen, in die sich der Spieler dann eventuell verewigen kann. Danach werden die Punkte gelöscht und der Room und damit das Spiel, neugestartet.
      Sollte es sich jedoch nicht um die letzte Instanz vom Typ obj_organell gehandelt haben, dann wird durch das scr_virus_alarm Skript ein neues Ziel gesucht und ganz gleichgültig, ob das Ziel zerstört wurde oder nicht, wird in den letzten beiden Zeilen ein blauer Ring-Effekt erzeugt und Alarm 0, der -wie inzwischen bekannt- ebenfalls das scr_virus_alarm Skript aufruft, wieder auf 10-20 Steps gesetzt. Da am Anfang die Geschwindigkeit auf 0 gesetzt wurde und da das Object, mit dem die Kollision stattfand, die Eigenschaft solid besitzt, findet bis zum Ablauf des Alarms kein neuer Aufruf des Collision Events mehr statt.

      Das obj_virus ist damit fertig und einsatzbereit. Zu Testzwecken können Sie einen Room erstellen (Resources->Create Room) und mehrere Instanzen der beiden Objects verteilen. Wenn Sie dann das Spiel starten (F5), werden die Viren die Organellen angreifen und Sie können sie mit der Maus „totklicken“.

      obj_controller
      Das Spiel ist allerdings noch nicht sonderlich spannend, da wir spätestens beim zweiten Versuch bereits wissen, wo sich die Viren befinden und diese rechtzeitig ausschalten können. Was dem Spiel noch fehlt, ist ein Mechanismus, der die Viren und Organellen zufällig erzeugt und ständig neuen Nachschub an Viren erzeugt, die mit der Zeit immer stärker und zahlreicher werden, so dass der Spieler irgendwann keine Chance mehr gegen die Übermacht hat. Außerdem fehlen noch einige grafische Effekte wie Laserstrahlen und das Fadenkreuz, sowie eine Punkteanzeige. Hier kommt unser Controller Object ins Spiel. Zunächst legen wir wieder einige Scripts an, die wir später Events zuweisen. Das sind für das Controller Object nur drei Stück: scr_controller_create, scr_controller_alarm und scr_controller_draw. Legen Sie ein neues Object mit dem Namen obj_controller an, erstellen Sie ein Create Event, ein Alarm Event „alarm 0“ und ein Draw Event und weisen Sie die Scripts entsprechend zu. Dieses Object benötigt kein Sprite, da wir das Draw Event gerade mit einem eigenen Script ersetzt haben, was das Zeichnen des eingestellten Sprites deaktiviert. Damit das Controller Object als letztes und damit über alles andere gezeichnet wird, geben Sie ihm eine Depth von -1. Kommen wir nun zu den Scripts:

      scr_controller_create:

      GML-Quellcode

      1. x1=0;
      2. y1=0;
      3. x2=0;
      4. y2=0;
      5. alpha=0;
      6. instance_create(
      7. random(room_width/2)+room_width/4,
      8. random(room_height/2)+room_height/4,
      9. obj_organell);
      10. do{
      11. x=random(room_width/2)+room_width/4;
      12. y=random(room_height/2)+room_height/4;
      13. nearest=instance_nearest(x,y,obj_organell);
      14. if (point_distance(x,y,nearest.x,nearest.y)>50)
      15. instance_create(x,y,obj_organell);
      16. } until (instance_number(obj_organell)==10)
      17. scr_controller_alarm();
      Alles anzeigen

      Zunächst werden 5 lokale Variablen x1,y1,x2,y2 und alpha deklariert, die später zum Zeichnen des Laserstrahls verwendet werden sollen. Danach wird eine Instanz von obj_organell an einer zufälligen Position, in einem Bereich, der ein Viertel des Rooms ausmacht und sich in dessen Mitte befindet, platziert. In der darauf folgenden nachgetesteten Schleife werden so lange neue Instanzen platziert, bis 10 Organellen existieren. Dabei wird darauf geachtet, dass die einzelnen Instanzen einen Mindestabstand von 50 Pixeln haben, damit sie nicht gelegentlich ineinander kleben. Nach der Schleife wird das Skript scr_controller_alarm gestartet, welches dafür sorgt, dass in regelmäßigen Abständen neue Viren erzeugt werden.

      scr_controller_alarm:

      GML-Quellcode

      1. if (random((score/50)+4)>3){
      2. switch(floor(random(4))){
      3. case 0:
      4. instance_create(random(room_width),-50,obj_virus);
      5. break;
      6. case 1:
      7. instance_create(-50,random(room_height),obj_virus);
      8. break;
      9. case 2:
      10. instance_create(random(room_width),room_height+50,obj_virus);
      11. break;
      12. case 3:
      13. instance_create(room_width+50,random(room_height),obj_virus);
      14. break;
      15. }
      16. }
      17. alarm[0]=room_speed;
      Alles anzeigen

      Mit einer anfänglichen Chance von 25% wird eine Instanz von obj_virus außerhalb des Rooms erstellt. Diese Chance wird mit jedem Punkt größer, nach 10 zerstörten Viren beträgt sie schon 50%. Die Erzeugung der Viren wird wieder durch Zufall in einer Switch-Case Verzweigung abgehandelt. Der Zufallswert kann die Werte 0,1,2 oder 3 annehmen, die jeweils für eine Richtung stehen. Ist der Wert 0, dann kommt das Virus von oben, bei 1 von links, bei 2 von unten und bei 3 von rechts. Am Ende wird wieder der Alarm neu gestellt, diesmal allerdings auf den room_speed, der die Steps pro Sekunde angibt, was bedeutet, dass es genau eine Sekunde dauern wird, bis das Script erneut ausgeführt wird.

      scr_controller_draw:

      GML-Quellcode

      1. // draw crosshair
      2. draw_sprite(spr_crosshair,0,mouse_x,mouse_y);
      3. // create red laser beam
      4. if (mouse_check_button_pressed(mb_left)){
      5. alpha=0.75;
      6. switch(floor(random(4))){
      7. case 0: // top border of the room
      8. x1=random(room_width-20);
      9. x2=x1+20;
      10. y1=0;
      11. y2=0;
      12. break;
      13. case 1: // left border of the room
      14. x1=0;
      15. x2=0;
      16. y1=random(room_height-20);
      17. y2=y1+20;
      18. break;
      19. case 2: // bottom border of the room
      20. x1=random(room_width-20);
      21. x2=x1+20;
      22. y1=room_height;
      23. y2=y1;
      24. break;
      25. case 3: // right border of the room
      26. x1=room_width;
      27. x2=x1;
      28. y1=random(room_height-20);
      29. y2=y1+20;break;
      30. }
      31. }
      32. alpha-=0.15; // laser fades away
      33. // draw red laser beam
      34. draw_set_alpha(alpha);
      35. draw_set_color(c_red);
      36. draw_triangle(x1,y1,x2,y2,mouse_x,mouse_y,false);
      37. // draw score text
      38. draw_set_alpha(1);
      39. draw_text(25,25,“SCORE: “+string(score));
      Alles anzeigen

      Dieses Script ist etwas lang geraten, weshalb es zur Übersicht beiträgt, wenn man die einzelnen Schritte im Code kommentiert. Ein Kommentar ist durch zwei Schrägstriche gekennzeichnet, die dem Interpreter signalisieren, dass er den Rest der Zeile ignorieren soll.
      Die erste Anweisung zeichnet das Fadenkreuz auf die Koordinaten der Maus, damit der Spieler nicht mit dem Standard Windows Mauscursor schießen muss.
      Danach wird überprüft, ob die linke Maustaste gerade eben geklickt wurde. Ist dies der Fall, dann wird die lokale Variable alpha auf 0.75 gesetzt und anschließend, wie zuvor, in einer Switch-Case Verzweigung per Zufall der Bildrand ausgewählt, von dem der Laserstrahl kommen soll. Dabei werden zwei Punkte (x1,y1) und (x2,y2) festgelegt, die einen Abstand von 20 Pixeln zueinander haben. Zusammen mit der Mausposition existieren nun 3 Punkte, durch die mit der Funktion draw_triangle(x1,y1,x2,y2,x3,y3,outline) ein rotes Dreieck gezeichnet wird. Durch die Zeilen alpha-=0.15; und draw_set_alpha(alpha); erscheint das Dreieck leicht transparent und wird dann innerhalb von vier Steps komplett ausgefadet. Dies erzeugt einen wesentlich weicheren Effekt und damit einen glaubwürdigeren Laserstrahl.
      Die letzten zwei Zeilen deaktivieren die Transparenz und schreiben den aktuellen Punktestand auf die Koordinaten (x=25,y=25). Auch hier könnte man mit dem Befehl draw_set_color(color) noch einmal die Textfarbe ändern oder eine Schriftart mit draw_set_font(font) festlegen.

      2.4 Rooms

      Das Spiel ist fast fertig. Löschen Sie den eventuell vorhandenen Room, falls Sie vorher schon einmal getestet haben, ob das Spiel funktioniert und erstellen Sie einen neuen (Resources->Create Room). Zuerst platzieren Sie das obj_controller Object irgendwo im Room. Sie müssen im objects Tab der Room Properties sein, um Objects auszusuchen und platzieren zu können. Das Controller Object erzeugt alle anderen Objects, weswegen es das einzige ist, das wir im Room setzen müssen.
      Gehen Sie auf den Tab backgrounds, klicken Sie auf das Drop-Down Menü, das momentan <no background> anzeigt und wählen Sie bgr_game als Hintergrundbild aus.
      Unter settings können Sie dem Room noch einen Namen geben und die Größe auf das Hintergrundbild anpassen, indem Sie bei Width 800 und bei Height 600 eintragen.

      2.5 Abschluss des Projektes

      Global Game Settings
      Das Spiel ist endlich fertig, es müssen nur noch einige Kleinigkeiten angepasst werden. Der vorletzte Punkt im Ressourcen-Explorer heißt Global Game Settings und erlaubt grundlegende Einstellungen am Spiel. Zuerst sollten wir im Tab Graphics die Option Display the cursor deaktivieren, damit der normale Mauszeiger von Windows nicht noch zusätzlich über dem Fadenkreuz gezeichnet wird. Außerdem sollten wir die Option Let <F5> save the game and <F6> load a game unter dem Tab other deaktivieren, damit der Spieler nicht durch wiederholtes Speichern und Laden schummeln kann.

      Sounds
      Das Spiel enthält noch keine Sounds oder Musikuntermalung. Das Integrieren von Sounds stellt jedoch keinen großen Aufwand dar. Es müssen lediglich Ressourcen vom Typ Sound erstellt und in den Scripts an den entsprechenden Stellen mit der Funktion sound_play(sound) gestartet werden. Um den Sound in Schleife zu spielen, was für Musik recht praktisch ist, existiert die Funktion sound_loop(sound).

      Menü
      Das Spiel besteht momentan nur aus einem Raum, was nicht sehr professionell wirkt. Besser ist es, wenn eine Partie erst über ein Hauptmenü gestartet wird, das auch Funktionen zum Anzeigen des Highscores und Beenden des Spiels bietet. Erstellen Sie dazu einen schönen Background, drei Sprites für die anklickbaren Buttons „New Game“, „Show Highscore“ und „Exit“ und drei Objects, die diese Sprites benutzen. Jedes Object bekommt ein Mouse Event „Left Button“, das im ersten Fall die Funktion room_goto_next(), im zweiten Fall highscore_show(-1) und im dritten Fall game_end() aufruft. Ob Sie Execute Code, Execute Script oder die passenden Drag&Drop Actions benutzen, bleibt Ihnen überlassen. Zuletzt müssen Sie nur noch einen neuen Room erstellen, ihn im Ressourcen-Explorer an die erste Stelle der Liste ziehen und die drei neuen Objects darin platzieren sowie den Background einstellen.

      Create Executable
      Damit das Spiel auch von anderen Menschen gespielt werden kann, die nicht den Game Maker besitzen, können Sie mit dem Befehl Create Executable aus dem File Menü eine allein lauffähige Windows exe Datei erzeugen lassen. Dieses Spiel unterliegt keiner Lizenzpflicht seitens des Game Makers und kann kostenlos veröffentlicht oder auch verkauft werden.



      Herzlichen Dank an Kilik, der den kompletten Text korrekturgelesen hat und an ElementZero, der maßgeblich an der Entstehung der Spielidee für das Lernprojekt beteiligt war.

      Dieses Tutorial ist (der größte) Teil meines "wissenschaftlichen Berichts" mit dem Titel "Entwickeln von PC-Spielen basierend auf der Software Game Maker Version 7.0 von Prof. Overmars", den ich im Rahmen meines Studiums schreiben musste. Die vollständige PDF befindet sich hier: gamemaker.pdf

      Spiele, die auf diesem Tutorial basieren können ohne Einschränkungen verbreitet werden, eine Nennung in den Credits ist nicht nötig.
      Ohne mein Einverständnis dürfen jedoch weder dieses Tutorial noch die "wissenschaftliche Arbeit" vollständig oder in Auszügen weiterverbreitet werden.
      Dateien
      Einige meiner Spiele:
    • Cool. :D
      Ich hab mir das gleich ausgedruckt, eingehüllt und eingeheftet.
      Ich frage mich nur, warum hier keiner ein Feedback abgibt?
      Computer können uns bei Entscheidungen helfen.
      Bei welchen müssen wir entscheiden.


      ________________________________________________________________________________________________________________
      Diese Signatur wurde bereits 84 mal editiert, zuletzt von »KillerZwerk« (Jetzt, 14:56)
    • echt super für einsteiger wie ich ,
      aber ne kleine frage ich wollte mal das spiel testen aber es kommt dann mitten im spiel

      ERROR in
      action number 1
      of Collision Event with object obj_organell
      for object obj_virus:

      In script scr_virus_attack:
      Error in code at line 13:
      effect_create_above(ef_ring,(x+other.x)/2,(y+other.y)/2,1,c_blue);

      at position 2: This function is only available in the Pro Edition.

      Was ist den daran nicht OK :P

      MFG
      AZ
    • Also erstmals klasse Tutorials interceptors klasse Leistung.... und zum Problem von AtzeZork es geht bei dir nicht weil die die Free/Trial Version des Gamemakers hast es wird ja auch aufgeschrieben "at position 2: This function is only available in the Pro Edition."
      Wir stehen zusammen und wir fallen zusammen
    • Freut mich, dass manche dieses Tutorial nützlich finden (und es sogar ausdrucken und abheften 8o )
      Wie ich auch (sogar rot hervorgehoben!) schreibe, gibt es einige Zeilen (durch das Kommentar "// nur in GM 7.0 Pro" gekennzeichnet), die nicht mit der unregistrierten Version funktionieren. Wenn man diese aber einfach weglässt, sollte es eigentlich laufen (fehlen dann halt die Explosionseffekte).
      Einige meiner Spiele:
    • Benutzer online 1

      1 Besucher