Wie erstelle ich ein Jump'n Run Game?

Dieses Tutorial hilft euch beim Einstieg in GDevelop:
Wir erstellen ein simples Jump'n Run Spiel in dem der Spieler von Plattform zu Plattform springt und Münzen einsammelt.

Wenn ihr mehr an der Erstellung eines Shooters interessiert seid könnt ihr auch mit diesem Anfänger Tutorial weiter machen.

Denkt daran, dass ihr euch auch auf der Getting Started Seite einen grundlegenden Überblick über die Software verschaffen könnt. Dort werden die grundlegenden Konzepte und das Interface von GDevelop erklärt

GDevelop Download

Falls ihr GDevelop noch nicht auf der Platte habt könnt ihr es euch hier von der offiziellen Website herunterladen: http://compilgames.net.
Dort findet ihr immer die aktuellste Version.

Nach der Installation / dem Entpacken (je nachdem für welchen Download ihr euch entschieden habt) erscheint nach dem Start von GDevelop der Willkommensbildschrim:

Über diesen Link erhaltet ihr einen kurzen Überblick über das Benutzerinterface von GDevelop
Das Aussehen der Entwicklungsumgebung (IDE) kann sich durchaus unterscheiden. Im Menü File > Options lässt sich unter Appearance ein beliebiges Theme auswählen.

Ein neues Spiel erstellen

Klickt oben im Ribbon auf New um ein neues Projekt zu erstellen.
Es öffnet sich ein Fenster in dem ihr auswählen könnt auf welcher Plattform euer Spiel basieren soll, sowie einige anpassbare Templates (Die Plattform lässt sich später noch ändern).
Wählt für dieses Tutorial die Web Platform aus und klickt auf “Empty project”:

Wählt ebenfalls ein Verzeichnis und einen Dateinamen für Euer Spiel und klickt auf “Ok” um das Projekt zu erstellen.
Eine erste Scene wird automatisch erstellt und geöffnet.

Ladet euch die nötigen Bilder und Ressourcen herunter die für dieses Tutorial benötigt werden

Bevor es weiter geht, benötigen wir einige Grafiken für unser Spiel.
Ihr könnt sie euch hier herunterladen: http://www.compilgames.net/dl/PlatformerTutorialResources.zip

Wenn der Download abgeschlossen ist, entpackt den Inhalt der Zip Datei in den neuen Projektordner.

Erstellen des Spieler Objekts

Der Spieler kontrolliert einen Charakter, der in der Lage ist zu Springen und sich über Plattformen zu bewegen. Wir erstellen nun das entsprechende Objekt.
Klickt mit der rechten Maustaste in die Mitte der grauen Fläche der Szene und wählt Add a new object. Es öffnet sich ein Fenster in dem sich die Art des Objekts auswählen lässt. Wählt hier als Typ Sprite aus und bestätigt mit Ok.

Der Objekt Editor öffnet sich. Aktuell enthält das Objekt lediglich eine leere Animation. Um dies zu ändern fügen wir der leeren Animation ein Bild hinzu. Klickt hierzu mit der rechten Maustaste auf die weiße Fläche im unteren Bereich des Fensters und wählt Add an image from a file:

Wählt aus dem Projektverzeichnis das Bild p1_stand aus und klickt auf Open: Das Bild wird dem Objekt hinzugefügt. Ihr könnt den Editor nun schließen. Das Objekt wird nun in der Szene angezeigt:

Standardmäßig werden alle neuen Objekte mit dem Namen NewObject versehen. Um dies zu ändern, wählt das Objekt im Objekt Explorer auf der rechten Seite des Fensters mit der linken Maustaste aus und betätigt F2 um das Objekt umzubenennen. Gebt als neuen Namen Player ein und bestätigt mit Enter. (Man kann objekte auch über das Kontextmenü und den Eintrag “Rename” umbenennen)

Plattformen hinzufügen

Lasst uns nun ein weiteres Objekt erstellen, welches als Plattform dienen soll:

Fügt der Szene wie zuvor über einen Rechtsklick in den grauen Bereich ein objekt hinzu Add an object. Dieses Mal wählen wir als Typ Tiled sprite aus:

Im Moment ist es noch ausgegraut, sobald wir allerdings auf Ok klicken werden wir von GDevelop gefragt ob wir die zugehörige Erweiterung aktivieren möchten: Bestätigt die Frage mit Yes.

Das neue Objekt wird im Editorfenster geöffnet: Auf der linken Seite ist der Ressource Manager zu sehen welcher sämtliche im Projekt enthaltenen Bilder anzeigt. Wir fügen der Liste nun ein Bild hinzu indem wir auf das + Zeichen in der Werkzeugleiste klicken:

Wählt nun grassHalfMid.png aus. Das Bild wird nun der Liste hinzugefügt. Klickt es in der Liste an und betätigt die Schaltfläche neben dem Textfeld unten um automatisch den Namen des Bildes einzufügen:

Ihr könnt den Editor nun mit einem Klick auf Ok schließen.
Das Objekt wurde der Szene hinzugefügt aber es ist ziemlich winzig. Benutzt die Ziehpunkte um es zu vergrößern bis es wie eine Plattform aussieht:

Denkt daran die Plattform unter dem Player Objekt zu platzieren um zu verhindern, dass der Spieler aus dem Bildschirm herausfällt sobald das Spiel gestartet wird.

Benennt das Objekt zuletzt noch im Objekt Editor auf den Namen Grass um.

Objekte mit Automatismen versehen

Prinzipiell ließe sich die Bewegung des Spieler Charakters durch das Event System erstellen. Allerdings wäre dies ein relativ langer und komplizierter Prozess um ein einwandfreies System für unser Jump'n Run Spiel zu erschaffen. Um dies zu umgehen werden wir uns an GDevelops vorgefertigten Automatismen bedienen welche uns diese Arbeit abnehmen.

Klickt doppelt auf das Player Objekt in der Szene. Dadurch wird ein Raster mit Eigenschaften des Objekts angezeigt. Im unteren Bereich findet man den Eintrag Add behavior. Klickt darauf um dem Player einen Automatismus zu verpassen:

Es erscheint eine Liste mit verfügbaren Automatismen. Wählt für dieses Objekt den Platformer object Automatismus aus und klickt auf Ok:

Das wars. Wie ihr seht wird der neue Automatismus nun ebenfalls unter den Eigenschaften des Player Objekts angezeigt. Dort kann man unter Anderem die Sprungkraft festlegen. Setzt den Wert jump speed auf 800 um höher zu springen.

Nun müssen wir Objekte, die als Plattformen dienen sollen noch als Solche markieren. Anderenfalls würde der Spieler einfach durch sie hindurch fallen, auch wenn er damit kollidiert.
Klickt auf das Platform Objekt in der Szene und wählt in den Eigenschaften erneut Add behavior:

Dieses Mal wählen wir den Platform Automatismus aus und klicken auf Ok:

Denkt daran, dass Automatismen auf alle Instanzen des Objekt angewendet werden die sich in der Szene befinden. Wenn ihr ein weiteres Plattform Objekt erstellt erhält es automatisch die zuvor festgelegten Automatismen. Weitere Instanzen eines Objekts lassen sich übrigens durch ziehen des Objekts aus dem Objekt Explorer in die Szene erschaffen. Man kann ebenfalls bei gedrückter STRG Taste über der vorhandenen Instanz in der Szene durch verschieben der Plattform eine Kopie erstellen.

Vorschau starten

Nun werden wir testen ob unsere zuvor festgelegten Verhaltensweisen (eng: Behaviours) auch funktionieren:

Klickt im Scene Ribbon auf Preview:

Der Standardbrowser wird geöffnet und das Spiel startet:
Der Charakter lässt sich mit den Pfeiltasten bewegen. Gesprungen wird per Shift Taste. Bis jetzt besitzt das Objekt keinerlei Animationen. Diese werden wir später noch hinzufügen.

Sollte sich das Objekt nicht bewegen oder durch den Boden fallen, vergewissert euch die richtigen Automatismen gewählt zu haben.

Unterschiedliche Plattformen hinzufügen

Wir können mehr als nur eine Art von Plattform benutzen. Fügt ein neues Objekt in der Szene ein indem ihr auf Add an object klickt.

Wählt ein Sprite Objekt, klickt auf Ok und sucht anschließend im Editor nach dem Bild Grass.png um es der Standardanimation hinzuzufügen:

Schließt den Editor und ändert den Namen des Objekts rechts im Objects Editor in Platform um:

Anschließend fügt ihr wie zuvor einen Platform Automatismus hinzu. (Doppelklick auf das Objekt in der Szene oder im Object Editor, dann wählt Add behavior und anschließend den Platform Automatismus) Die beiden Objekte werden nun als Plattformen behandelt. Ihr könnt auch mehrere davon in die Szene einfügen und im Preview von Plattform zu Plattform springen.

Bevor es weiter geht möchtet ihr vielleicht die Hintergrundfarbe der Szene anpassen. Öffnet dazu den Projekt Manager indem ihr im linken Bereich des Fensters mit der rechten Maustaste auf den Namen der Szene (“New scnene”) klickt und Edit the properties auswählt.

Ihr könnt nun über einen Klick auf das farbige Rechteck neben 'background colour' die Hintergrundfarbe der Szene ändern. Hintergrund Objekten werden wir uns im späteren Verlauf dieses Tutorials ebenfalls noch zuwenden.

Stopp ! Zeit zu Speichern !

Bevor es weiter geht, denkt immer daran häufig zu speichern. Klickt dazu im Ribbon auf File und anschließend auf Save:

Die Spielfigur animieren

Bis jetzt zeigt das Player Objekt immer das selbe Bild. Mit Hilfe von Ereignissen (eng: Events) können wir die Animationen je nach ausgeführter Aktion (z.B. Laufen, Springen, etc.) dynamisch anpassen.

Aber zunächst müssen wir die entsprechenden Animationen dem Player Objekt hinzufügen. Öffnet hierzu den “Sprite Editor” durch einen Doppelklick auf das Player Objekt in der Szene.
Klickt im oberen linken Bereich auf das + Symbol in der Werkzeugleiste um eine neue Animation hinzuzufügen:

Eine neue Animation mit der Bezeichnung Animation 1 wird der Liste hinzugefügt. Klickt sie an um sie auszuwählen. Momentan ist sie noch leer also klicken wir mit der rechten Maustaste in den weißen Bereich unten und wählen “add an image from a file”. Sucht nach dem Bild p1_jumping.png und wählt es aus:

Diese Animation wird verwendet wenn sich das Objekt in der Luft befindet.
Wir benötigen noch eine weitere Animation welche abgespielt wird wenn der Spieler auf Plattformen umher läuft. Also erstellen wir eine weitere Animation und fügen diesmal gleich fünf Bilder hinzu: p1walk03.png, p1walk04.png, … und p1_walk07.png.

Diese Bilder werden später im Spiel in schneller Abfolge angezeigt um eine flüssige Bewegung zu erzeugen. Dazu müssen wir allerdings noch ein paar Einstellungen vornehmen. Klickt in der linken Liste mit der rechten Maustaste auf Animation 2 und wählt im Kontextmenü Loop the animation. Dies sorgt dafür, dass die Animation in Endlosschleife wiederholt wird und nach Erreichen des letzten Bildes nicht einfach stehen bleibt.
Klickt als nächstes auf Time between each image und ändert den Wert im daraufhin erscheinenden Dialog auf 0.05. Dadurch wird die Animation schneller abgespielt als der Standardwert (Ein Bild pro Sekunde).
Der Editor sollte nun folgendermaßen aussehen:

Ihr könnt euch die Animation auch anzeigen lassen indem ihr den kleinen “play” Knopf oben im mittleren Bereich in der Werkzeugleiste betätigt.
Wenn alle Animationen erstellt wurden kann der Editor geschlossen werden.

Nun werden wir Spiellogik erstellen mit der die soeben erstellten Animationen in Abhängigkeit von den Aktionen des Charakters abgespielt werden. Wechselt in den “Events Editor” indem ihr oben auf den Reiter Events neben Scene klickt:

Wählt oben im Ribbon nun Add an event aus um ein neues Ereignis zu erzeugen:

Das Ereignis wird mit einer leeren Liste von Bedingungen (eng: Conditions - auf der linken Seite) und einer leeren Liste von Aktionen (eng: Actions - auf der rechten Seite) erstellt. Bewegt den Mauszeiger über die Bedingungsliste und wählt Add a condition aus der Liste aus, die beim überfahren mit der Maus erscheint:

In diesem Ereignis prüfen wir ob der Spieler gerade dabei ist zu Springen um anschließend die passende Sprung-Animation abzuspielen.

Wählt in der “Conditions List” unter PlatformAutomatism den Punkt Is jumping aus. In den Parametern auf der rechten Seite wählt ihr als Objekt Player (wir möchten herausfinden ob das Player Objekt springt) und PlatformerObject als Automatismus:

Klickt auf Ok um die neue Bedingung einzufügen.
Nun müssen wir nur dem Event nur noch eine Aktion hinzufügen:

Ruft im rechten Bereich die Aktionsliste auf, so wie ihr es zuvor für die Bedingungen getan habt. Wählt nun in der Kategorie Sprite

> ''Animations and images'' den Punkt ''Change the animation''. Als Objekt nehmen wir wieder den ''Player'', als ''Modification sign'' wählen wir ''='' und als ''Value'' (Nummer der Animation) geben wir eine ''1'' ein um die Sprunganimation abzuspielen.\\

K

lickt auf Ok um die Aktion zu erstellen. Nun wird die Sprunganimation angezeigt wenn der Spieler sich in der Luft befindet.

Erstellt ein weiteres Ereignis aber diesmal mit Player is falling als Bedingung ( Ihr könnt das Ereignis auch kopieren und die Kopie per Doppelklick bearbeiten ):

Anschließend setzen wir die Animation 0 wenn das Player Objekt den Boden berührt und die Animation 2 wenn der Spieler beginnt sich zu bewegen.
Dies kann durch zwei Ereignisse erreicht werden: Das Erste prüft ob sich das Player Objekt auf dem Boden befindet und ob es sich bewegt. In diesem Fall wird Animation 2 aktiviert. Das Zweite prüft ob sich das Player Objekt auf dem Boden befindet und es sich nicht bewegt. In diesem Fall wird Animation 0 aktiviert. Hierfür nutzen wir ein schönes Feature namens Sub events: Da wir die selbe Bedingung zwei Mal prüfen ( Der Spieler befindet sich auf dem Boden ) können wir diese Bedingung in einem Ereignis unterbringen und anschließend Unterereignisse hinzufügen: Sub Events werden nur ausgeführt wenn ihre “Eltern” Bedingungen erfüllt sind.

Hügt ein Ereignis Player is on the floor als Bedingung ein. Bewegt den Mauszeiger anschließend über das Ereignis und wählt Add a sub event: Ein leeres Unterereignis wird erstellt.

Fügt diesem leeren Ereignis die Bedingung Player is moving hinzu. Anschließend die Aktion Do =2 to the current animation of player.

Erstellt nun ein zweites Sub Event. Dieses Mal mit der umgekehrten Bedingung, sodass diese erfüllt ist wenn das Player Objekt nicht in Bewegung ist:

Passt ebenfals den Animation Parameter an und setzt ihn auf 0:

Wenn ihr nun die Vorschau startet könnt ihr sehen wie sich die Animation verändert:

Falls etwas nicht funktioniert vergewissert euch, dass die Ereignisse genau wie oben beschrieben aussehen.
Ihr könnt sehen, dass das Player Sprite nicht gespiegelt angezeigt wird wenn ihr nach links geht. Glücklicherweise gibt es eine Aktion um Sprites zu spiegeln.

Wechselt zurück zum Ereignis Editor und fügt ein neues Ereignis hinzu: Erstellt eine Bedingung die Prüft ob die Left Taste gedrückt wird.

Denkt darann, dass ihr auch auf den Button rechts neben dem Eingabefeld klicken könnt und die entsprechende Taste anschließend einfach betätigen braucht um sie einzufügen anstatt deren Namen manuell in das Feld einzugeben.

Fügt nun noch eine Aktion zum Drehen (eng: flip) des Sprites hinzu:

Jetzt fehlt nur noch eine Aktion um das Sprite beim laufen nach Rechts wieder umzudrehen. Fügt dazu ein Ereignis mit der Bedingung Right is pressed hinzu und dreht das Sprite in seine ursprüngliche Richtung:

Die Kamera auf dem Spieler zentrieren

Es gibt mehrere Wege die Kamera dem Spieler folgen zu lassen. Fürs Erste gehen wir den einfachen Weg und benutzen die Aktion Center the camera on an object. Fügt diese Aktion einem leeren Ereignis ohne Bedingung hinzu:

Lest euch diesen Thread (Englisch) im offiziellen Forum durch wenn ihr die Kamerabewegung auf die Fenstergröße beschränken möchtet.

Eine 'durchspringbare' Plattform hinzufügen

Bis jetzt waren alle Plattformen felsenfest aber wir können auch Plattformen erstellen durch die der Spieler hindurchspringen kann:
Erstellt eine neues Sprite Objekt und fügt das Bild bridge.png hinzu:

Nennt das Objekt zum Beispiel “Jumpthru”:

Fügt dem Objekt anschließend den “Platform” Automatismus (Behaviour) hinzu wie wir es bereits zuvor gemacht haben. Wenn ihr fertig seid ändert die Type Eigenschaft in den Objekteigenschaften auf den Wert “Jump thru platform”:

Das wars! Wenn ihr nun eine Vorschau startet könnt ihr durch diese Plattformen hindurch springen.

Münzen und Punkte hinzufügen

Lasst uns dem Level ein paar Münzen zum einsammeln hinzufügen: Erstellt ein neues Objekt namens Coin mit coinGold.png als Sprite. Zieht das Objekt ein paar Mal per Drag & Drop in die Szene oder kopiert eine bereits vorhandene Instanz mit gedrückter Strg Taste um es zu Klonen.

Nun zerstören wir das Coin Objekt sobald es vom Spieler Charakter berührt wird. Fügt ein neues Ereignis mit der Bedingung Kollision zwischen Coin und Player hinzu:

Danach ergänzen wir das Ganze um eine Aktion zum Löschen der Coin Instanz (Ihr könnt es in “All objects > Objects > Delete an object” finden ). Beachtet, dass diese Aktion sich ausschließlich auf die Coin Instanz auswirkt auf die die jeweilige Bedingung zutrifft, sprich die Münze mit der der Spieler in Kollision steht. Diese Mächtige Funktion ermöglicht es Aktionen nur auf die Objekte anzuwenden auf die die in den Bedingungen spezifizierten Kriterien zutreffen.

Wir können auch einen kleinen Sound abspielen wenn die Münze eingesammelt wird. Fügt nach Delete Object eine “Play the sound” Aktion hinzu und wählt als Sound Datei coin.wav aus:

Punkte aktualisieren und anzeigen

Wir verwenden eine Variable um die Punkte (Score) des Spielers zu speichern und zu aktualisieren. Variablen sind nützlich um ein Vielzahl von Informationen zu speichern. Es gibt Szenen Variablen ( die am häufigsten verwendeten ), globale Variablen ( Variablen, die zwischen sämtlichen Szenen des Spiels geteilt werden ) und Objekt Variablen ( individuell für jede Objekt Instanz, aber dazu später mehr wenn wir anfangen Gegner einzufügen ).
Fügt eine Aktion im letzen Ereignis das wir erstellt haben hinzu:

Wählt die Aktion Variables > Value of a variable. Diese Aktion wird verwendet um 100 zur Score Variable hinzuzufügen, füllt die Parameter wie folgt aus:

Bedenkt, dass ihr Variablen nicht zwingend deklarieren müsst bevor ihr sie nutzt: Wenn ihr einen Variablennamen verwendet der noch nicht existiert legt ihn GDevelop automatisch für euch an. Man kann Variablen allerdings auch explizit deklarieren und einen Anfangswert vergeben. Hierzu klickt einfach auf die Schaltfläche neben dem ersten Parameter um eine Liste mit allen deklarierten Szenen Variablen zu öffnen.

Das Ereignis sollte nun folgendermaßen aussehen:

Um die Variable auf dem Bildschirm anzuzeigen benötigen wir ein Text Objekt. Fügt der Szene ein neues Objekt hinzu und wählt als Typ Text aus:

Bearbeitet das Objekt, ändert die Textfarbe in schwarz und erhöht die Schriftgröße ein wenig:

Wenn ihr fertig sein gebt dem Text Objekt den Namen ScoreText und fügt eine Instanz davon in die Szene ein:

Öffnet erneut den Events Tab und fügt ein neues, leeres Ereignis hinzu. Wählt als neue Aktion Modify the text aus der “Text object” Kategorie. Fügt den Namen des Objekts ( ScoreText ) als ersten Parameter ein, dann ( = ) als zweiten Parameter sowie den anzuzeigenden Text im letzten Parameter: Wir möchten als Text “Score:” gefolgt vom Inhalt der Variable Score ausgeben.
Um dies zu erreichen schreiben wir den Ausdruck Variable(Score) was den Inhalt der Score Variablen liefert. Es handelt sich dabei allerdings um einen Zahlenwert den wir erst in eine Text Zeichenkette ( String ) konvertieren müssen. Dies erledigt die ToString Funktion. Zuletzt müssen noch der Text “Score:” und der Inhalt der Variablen miteinander verbunden werden. Dies geschieht mittels des + Zeichens:

“Score:”+ToString(Variable(Score))

Es steht eine Vielzahl von Funktionen zur Verfügung: Klickt einfach auf die Schaltfläche neben den Parametern um den Parameter Editor zu öffnen. Dort seht ihr sämtliche Parameter die ihr verwenden könnt.
Das Ereignis sollte nun folgendermaßen aussehen:

Wenn ihr die Vorschau öffnet um das Game probe zu spielen seht ihr, wie sich der Score Wert des Text Objekts jedes Mal erhöht wenn ihr eine Münze einsammelt. Allerdings wollen wir sicher gehen, dass der Score Wert dauerhaft sichtbar ist.
Um dies zu erreichen kehrt zum Szenen Editor zurück. Wir fügen hierzu eine neue Ebene (englisch “Layer”) hinzu und setzen das Text Objekt auf diese Ebene. Ihr könnt euch Ebenen als übereinander gelegte, transparente Glasscheiben vorstellen auf denen Objekte angezeigt werden: Indem wir ein Objekt auf eine andere Ebene verschieben gehen wir sicher, dass es dauerhaft angezeigt wird solange sich die Kamera der jeweiligen Ebene nicht verschiebt.

Klickt auf Layers' editor in der oberen Ribbon Leiste um den Ebenen Editor zu öffnen:

Fügt im Ebenen Editor einen neuen Layer hinzu:

Wählt diesen anschließend aus und schiebt ihn über den Base Layer:

Wenn ihr auf die neue Ebene doppelt klickt könnt ihr sie umbenennen. Gebt ihr zum Beispiel den Namen GUI.
Führt zuletzt einen Rechtsklick auf das Text Objekt in der Szene aus und bewegt es auf die neue GUI Ebene:

Jetzt wird der Text dauerhaft angezeigt. Vergewissert euch nur, dass es im Fenster korrekt positioniert ist. Ihr könnt das Ribbon benutzen um die Kamera auf den Szenen Ursprung zu zentrieren ( Klickt auf Return to the initial position und anschließend auf Mask um eine Maske um den sichtbaren Bereicht des Fenstern einzublenden:

Einen Gegner hinzufügen

Lasst uns dieses Tutorial zu Ende bringen indem wir einen Gegner hinzufügen der sich über die Plattformen bewegt.
Vergewissert euch, dass im Ebenen Editor der Base Layer ausgewählt ist ( andernfalls würden die neuen Objekte auf der GUI Ebene erstellt werden ) Dann erstellt die folgenden drei Objekte:

  • Ein Spriteobjekt für den Gegner
  • Ein Spriteobjekt zur Begrenzung der Gegnerbewegung nach links
  • Ein Spriteobjekt zur Begrenzung der Gegnerbewegung nach rechts

Das erste Sprite Objekt nennen wir Bad, es repräsentiert den Gegner und enthält eine Lauf Animation welche die Bilder slimeWalk1.png und slimeWalk2.png in einer Schleife abspielt.
Die anderen Beiden Objekte werden in GoLeft und GoRight umbenannt, sie dienen als Markierung um sicher zu stellen, dass der Gegner nicht von den Plattformen fällt. Platziert eine GoLeft Instanz am rechten Ende der Plattform sowie eine GoRight Instanz am linken Ende. Setzt anschließend eine Bad Instanz in die Szene und vergewissert euch, dass sie mit einer der beiden Markierungen kollidiert:

Den Gegner laufen lassen

Um den Gegner laufen zu lassen verwenden wir die normalen Bewegungsaktionen. Jeder Gegner merkt sich seine Bewegungsrichtung ( links oder rechts ) über eine Variable.

Fügt dieses Ereignis hinzu:

Anders als zuvor ändern wir hier keine Szenen Variable sondern eine Objekt Variable ( Die Aktion findet man in All Objects > Variables ). Wann immer ein Bad Objekt mit einem GoLeft Objekt kollidiert wird dessen GoLeft variable auf den Wert 1 gesetzt. Fügt ein weiteres ähnliches Ereignis hinzu welches den Wert der Variablen auf 0 setzt wenn Bad mit dem Objekt GoRight kollidiert:

Nun da sich der Gegner daran erinnern kann in welche Richtung er läuft brauchen wir nur noch den Wert der Variablen zu vergleichen und das Objekt zu bewegen.
Erstellt eine Ereignis in dem ihr prüft ob die Variable des Objekts Bad den Wert 0 hat. Fügt anschließend eine Aktion hinzu welche das Objekt Bad mit einer Kraft (englisch Force) von 50 Pixeln auf der X-Achse und 0 Pixeln auf der Y-Achse voranschiebt. Forces sind eingebaute Mechanismen um Objekte in der Szene zu bewegen ( Die Aktion ist unter “All Objects > Displacement > Add a force to an object” zu finden ). In diesem Fall bewegt die Kraft das Objekt mit einer Geschwindigkeit von 50 Pixeln pro Sekunde nach rechts:

Fügt ein ähnliches Ereignis hinzu welches Bad nach links bewegt wenn die Variable GoLeft von Bad den Wert 1 hat:

Wenn ihr nun die Vorschau startet sollte der Gegner sich zwischen den Markierungen hin und her bewegen. Falls nicht kontrolliert ob der Gegner am Anfang der Szene mit einer der Markierungen kollidiert ( Sollte dies nicht der Fall sein wird er sich gar nicht bewegen ). Prüft auch ob die Ereignisse korrekt sind.

Die Markierungen sind auch im Spiel sichtbar, um sie zu verbergen fügt dieses Ereignis hinzu:

Die Bedingung findet ihr in der Scene Kategorie, sie wir lediglich ein Mal zu Beginn der Szene ausgelöst. Die beiden Aktionen unter Objects > Visibility sind nützlich wenn man Objekte verbergen möchte während sie sich weiter in der Szene befinden.

Den Gegner zuerstören indem man auf ihn springt

Bevor wir dieses Tutorial abschließend sollte der Spieler in der Lage sein den Gegner zu zerstören indem er auf ihn springt.
Um dies zu bewerkstelligen fügen wir ein Ereignis mit zwei Bedingungen hinzu:

  • Die erste Bedingung prüft ob der Spieler mit dem Gegner kollidiert
  • Die zweite Bedingung prüft ob der Spieler gerade fällt (s. Plattformer Objekt Erweiterung)

Wenn beide Bedingungn zutreffen erlauben wir dem Spieler erneut zu springen und führen diese Atkion auch automatisch aus um den Eindruck zu erwecken er würde vom Gegner abprallen:

Wir haben die Bedingungen und die erste Aktion bereits zuvor verwendet. Die letzten beiden Aktionen findet ihr in der Platform behaviour Kategorie.

Hintergrund Objekte hinzufügen

Ein paar Objekte im Hintergrund zu platzieren ist sehr einfach: Fügt einfach ein paar Sprites hinzu und weist ihnen Bilder zu welche zur Szene passen.

Um sicher zu gehen, dass die Objekte hinter dem Spieler angezeigt werden wählt ihre Instanzen im Szenen Editor aus und tragt einen negativen Wert in ihrer Z-Order eigenschaft ein. Jedes Objekt mit einem höhreren Z-Wert wird anschließend vor ihnen angezeigt ( Ihr könnt euch Z-Order im Prinzip als die 3. Dimension vorstellen).

Vergewissert euch ebenfalls, dass sich die Objekte auf dem Base Layer befinden ( Die “Layer” Eigenschaft sollte leer sein ).

Das Spiel erweitern

Hiermit endet dieses Tutorial! Ihr könnt das fertige Spiel unter folgendem Link herunterladen. Falls etwas in eurem Projekt nicht funktioniert habt ihr die Möglichkeit es mit dem Refernezprojekt zu vergleichen. Eine erweiterte Version des Spiels befindet sich ebenfall in den mitgelieferten Vorlagen die ihr bei der Erstellung eines neuen GDevelop Projekts auswählen könnt.

Ihr könnt das Game auch online probespielen:
http://www.compilgames.net/games/WebPlatformer

Wie geht es weiter?

Ihr könnt euch die anderen Tutorials unter tutorials durchlesen oder einen Blick auf die Getting started page werfen.
Es gibt auch eine Menge Beispiele als Vorlagen welche ihr bei der Erstellung eines neuen Projekts in GDevelop auswählen könnt.

Falls ihr ein Problem hab könnt ihr eure Frage auch gerne im offiziellen Forum stellen.
Wenn ihr Anregungen für dieses Tutorial habt zögert nicht sie im Forum zu äußern. Ihr könnt dieses Tutorial auch selbstständig anpassen oder eigene Tutorials verfassen.
Erstellt euch einfach einen Account für dieses Wiki 8-)