Mrz 132015
 

In dieser Lektion wollen wir über den Zyklus einer Aktivität mehr lernen. Es geht einfach gesagt darum einen Intent zu empfangen und daraus Informationen zu lesen.

In der letzten Lektion haben wir die secondActivity gestartet indem wir einen unserer Knöpfe gedrückt haben. Jeder unserer Buttons hat seinen eigenen Intent. Nun werden wir jedem einzelnen Button seinen eigenen Song hinzufügen und auf dem Weg zum Ziel werden wir den Lebenszyklus unserer Aktivität kennen lernen.

In der letzten Lektion haben wir den Intent erstellt. Dies ist eine Nachricht mit Informationen über die gewünschte Aktion.

Nun werden wir in der secondActivity in der onCreate() Methode den folgenden Code hinzufügen:

Stellt auch gleich sicher, das ihr Intent importiert.

Nun müssen wir uns die Zeilen mal genauer anschauen. getIntent() empfängt den Intent, welcher die neue Aktivität gestartet hat.  In der nächsten Zeile speichern wir die integer „Nummer“ unseres Buttons der gedrückt wurde, in Fall das das fehlschlägt speichern wir die 1.

Um zu schauen ob wir auch alles richtig gemacht haben, werden wir den TextView Wert in der SecondActivity ändern. Dies haben wir auch schon in anderen Lektionen gemacht.

Wir werden nun Änderungen in der activity_second.xml Datei vornehmen.

Wir werden in der textView eine ID ergänzen.

Dann sollten wir das folgende Ergebnis haben:

Nun werden wir in der SecondActivity Klasse in der onCreate() Methode hinzufügen:

Langsam sollte man verstehen, wie alles funktioniert oder? Wir rufen ein Objekt mit seiner ID (R.id.textView) ab und leiten es weiter an TextView und speichern es dort unter tv.

Danach ändern wir den Wert von tv zur number (Nummer unseres Button). Dies konvertieren wir zu einem String, setText kann keine integer lesen. Die Nummer die gespeichert wird, ist die Nummer unseres Knopfes, welchen wir im vorherigen Bildschirm gedrückt haben. Nun werden wir diesen in der SecondActivity anzeigen:

K5L6B1 K5L6B2

So einfach ist das ganze. Nun werden wir anstatt eine Zahl anzuzeigen ein Lied abspielen.

In unserem Code ist auch noch ein kleiner Fehler eingebaut, versucht diesen von selber zu lösen, es ist nicht schwer.

Für diese App werden wir kostenlose Musik verwenden. Hierzu nehmen wir welche von Matt McFarlands: http://mattmcfarland.com/

Ich habe einfach die ersten 4 heruntergeladen:

1. Wouldn’t it be

2. Wicked

3. Warfield

4. Tunneled

Es kommt nicht darauf an, welche Dateien ihr verwendet. Für unsere App werde ich diese in den res/raw/ Ordner unserer App kopieren. Falls dieser Ordner noch nicht existiert, einfach auf res mit der rechten Maustaste und auf new und folder, dann könnt ihr ihn recht einfach erstellen. Danach noch kurz auf refresh und ihr sehr eure 4 Lieder. Um es einfach zu halten, habe ich alle 4 in song1, song2, song3, song4 umbenannt.

Nun gehen wir wieder in unsere SecondActivity in die onCreate() Methode, wo wir die Musik abspielen wollen. Nun müssen wir unter public class SecondActivity extends Activity { unseren Musikspieler integrieren.

Wir erstellen den Musikspieler namens mPlayer. Vergesst auch hier nicht, den benötigten Import durch zuführen. Wir initialisieren den mPlayer noch nicht, wir müssen erst die benötigten Titelinformationen einspielen.

Um zu schauen welcher Titel gerade spielt nutzen wir currentSong. Wenn wir durch den Home Button aus der App gehen, kann die App so sich daran erinnern, wo sie war und weiter spielen, wenn wir wieder in die App wechseln.

Nun zum Zyklus einer Aktivität. Erinnert euch daran, dass die onCreate() Methode sofort beim Start einer Aktivität ausgeführt wird. Also werden wir unsere Musik in dieser Methode einbinden:

 

Wir nutzen hier eine Reihe von Statements, welchen Titel wir spielen. Wir haben am Ende auch ein Standard gesetzt, im Fall irgendetwas läuft nicht wie gewünscht. Am Ende starten wir unseren mPlayer. Ganz einfach und klar.

Jetzt haben wir aber noch ein Problem. Wenn wir einen Anruf bekommen oder aus der App gehen, spielt unsere Musik einfach weiter. Die App weiß ja nicht, dass sie pausieren soll. Daher fügen wir eine onPause() Methode hinzu:

Diese Methode wird immer ausgeführt, wenn wir die App nicht direkt auf dem Display sehen. Dies ist auch der Fall, wenn wir den zurück Knopf verwenden um in die MainActivity zu gelangen. Wir werden hier als erstes die super.onPause() Methode ansprechen, dies wird benötigt da einige Aufrufe in der Aktivitäten Klasse onPause Methode (die Methode welche wir überschreiben) um eine anständige Systemfunktionalität zu gewährleisten.

Danach überprüfen wir einfach ob der mPlayer spielt und stoppen diesen.

Nun haben wir es geschafft unseren mPlayer zu pausieren, aber was ist wenn wir zurück in die App gehen? Die onCreate() Methode wird nicht aufgerufen werden, da wir diese schon vorher gestartet haben. Also müssen wir eine onResume() Methode hinzufügen:

Als erstes schauen wir nach ob unser mPlayer auch einen Wert besitzt. Es kann durchaus passieren, das der mPlayer vergisst, welchen Titel er abgespielt hat. Daher nehmen wir diesen dann aus unserem currentSong.

Danach rufen wir einfach wieder mPlayer.start() auf.

In dem Fall das wir die App komplett schließen, helfen wir dem System etwas aufzuräumen. Dies ist wichtig, dass unsere App keine wichtige Systemleistung verschlingt, welche andere Apps benötigen:

Auch hier rufen wir als erstes die super.onStop() Methode auf. Dies wird wieder benötigt um kritische Methoden zu benutzen um eine App zu beenden. Danach schauen wir ob der mPlayer gerade am spielen ist, falls dies der Fall ist, beenden wir diesen.

Nun können wir unsere App benutzen und unsere Musik anständig abspielen. Wenn wir die App pausieren oder verlassen, weiß die App genau was zu tun ist. Damit haben wir unsere erste Musik App entwickelt.

Ich hoffe ihr habt wieder viel gelernt beim erstellen dieser simplen Musik App. Nun sollten wir auch genau wissen, wie wir ein View (Bildschirmbereich) mit seiner ID (findViewById) herausfinden ob es ein TextView oder ein Button ist. Und wir können diese Information verarbeiten. Des Weiteren haben wir gelernt unser Layout graphisch und mit der .xml zu bearbeiten. Wir sind nun soweit Intents zu nutzen, um mit diesen Aktivitäten zu starten.

Nun haben wir alle ein Basis Verständnis wie ein Lebenszyklus einer Aktivität aussieht und arbeitet und können darauf weiter aufbauen.

Hier noch der benötigte Code:

MainActivity

 SecondActivity

 MusikApp Manifest

activity_main.xml

 activity_second.xml

 

Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.

Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, Danke sehr. Oder ein Klick auf die Werbung, hilft dabei diese Seite am laufen zu halten.

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 5 - Erstellen einer Musik App Teil 2
Feb 262013
 

Mit dieser Lektion schließen wir Kapitel 3 und führen eine grundlegende künstliche Intelligenz (artificial intelligence -AI) ein. In Kapitel 4 werden wir das Spiel auf Android portieren und grundlegend überarbeiten. Dabei werden wir dann auch ein komplexeres AI System einführen.

Künstliche Intelligenz

Hierbei geht es darum, dem Gegner eine Art menschliche Intelligenz zu geben, also AI. In der Spielentwicklung geht es darum den nicht vom Spieler gesteuerten Charakteren eine Art Intelligenz zu geben, um dass Spiel realistischer und anspruchsvoller zu gestalten. Nehmen wir Diablo 3 als Beispiel, hier trifft man auf eine Menge dieser künstlichen Intelligenzen.

1

Ich hatte euch hier schon einmal das Spiel Metal Slug vorgestellt. Darin ist ein wirklich klasse AI System programmiert. Je nach Entfernung zum Gegner, nimmt dieser eine andere Waffe und passt sich somit an die Spielsituation an.

2

 

All diese kleinen Feinheiten machen ein Spiel nicht nur schöner, sondern auch anspruchsvoller.

Verschiedene Arten von AI

Scripted AI: Nicht vom Spieler gesteuerte Figuren laufen in Mustern, dies kann man in frühen Pokemon Spielen sehr gut sehen

Situationally Aware AI: Nicht vom Spieler gesteuerte Figuren verhalten sich real. Wenn ein Toder auf der Straße liegt, rennen sie weg.

Rubberband AI: Nicht vom Spieler gesteuerte Figuren passen ihr verhalten daran an, wie gut das Spielverhalten des Spielers ist. Je besser er spielt, desto schwerer wird es.

2D Plattformen

Da wir ein 2D Spiel programmieren, werden wir uns erstmal hiermit beschäftigen.

Path-finding hierbei kann eine Gegner zu der Position des Spielers navigieren. In unserem Spiel möchten wir, dass der Heliboy sich unserem Roboter annähert. Sind wir auf einer Plattform, dann sollte der Heliboy auch hoch fliegen können.

Combat also das Kampfsystem. Wir werden versuchen, dass unsere Gegner sich an die Spielsituation anpassen. Wir werden einige Gegner haben, die wie Zombies zufällig immer näher kommen und die es nicht interessiert ob wir auf sie schießen oder nicht. Wir werden Gegner einbinden die uns verfolgen und welche die uns angreifen, falls wir zu nahe kommen.

Wir werden das meiste davon in Kapitel 4 umsetzen und in dieser Lektion ein kleines Beispiel in unser Spiel einfügen.

Gegner die uns verfolgen

Dazu werden wir nur ein paar Änderungen an der Enemy Klasse vornehmen:

Ich werde die Änderungen dieses mal nicht erklären, wir sollten nun alle in der Lage sein diese zu verstehen. Auch die Fehler, welche auftreten, könnt ihr mithilfe von Eclipse selbständig lösen. Damit endet auch Kapitel 3 und wir werden in Kapitel 4 von Grund auf neu beginnen.

In Kapitel 4 werden wir Android Programmierung im ganzen betrachten. Wir werden über den Play Store, die Limitierungen und einige andere Dinge reden. Des weiteren werden wir ein Grundgerüst erstellen, welches wir in möglichen späteren Spielen immer und immer wieder verwenden können. Zum Schluss werden wir unser einfaches Spiel aus den Kapiteln 2 und 3 auf Android portieren.

Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.

Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, Danke sehr. Oder ein Klick auf die Werbung, hilft dabei diese Seite am laufen zu halten.

Source Code

Falls einer hier einsteigen möchte oder nicht den ganzen Code abtippen möchte, habe ich hier das Projekt exportiert und ihr könnt diesen bei euch einfügen. Unter der Kategorie Eclipse und Import und Export habe ich erläutert wie ihr dies macht.

Kapitel 3 Lektion 9

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 8 – Gesundheitssystem Android Spielentwicklung

Feb 252013
 

In dieser Lektion werden wir ein Gesundheitssystem für unsere Heliboys hinzufügen und den Tod unseres Roboters.

Tod des Roboters

1

Jedes Spiel hat ein Ausfall-System eingebaut, dies Endet meistens mit dem Tod der Spielfigur und meist mit dem Neustart des Levels. Wenn nun unser Roboter in ein Loch fällt, wollen wir ausgegeben haben, dass dieser nun Tod ist. Dies gelingt uns in 3 Schritten:

1. Wir erstellen eine Variable die überprüft ob das Spiel noch läuft oder der Roboter Tod ist, also den Status des Spiels.

2. Je nachdem welche Status unser Spiel hat, werden wir verschiedene Teile der update() und paint()-Methode haben.

3. Wenn unser Roboter in ein Loch fällt, also die Y Variable außerhalb des Bildschirms ist, wird der Status des Spiels auf Tod gesetzt und das entsprechende Bild angezeigt.

1. den Status des Spiels erstellen

Hierzu werden wir ein Enum erstellen. Dies besteht aus Konstanten, also festen Variablen. Dazu fügen wir folgendes in der StartingClass hinzu:

Hier haben wir nun unser Enum erstellt. Darin sind die festen Variablen Running und Dead. Als nächstes setzen wir zu beginn des Spiels den Status auf Running.

Damit sich das Spiel nicht immer neu Aktualisiert, wenn unser Roboter gestorben ist, müssen wir die run()-Methode ändern. Dazu setzen wir ein IF-Statement innerhalb der Methode.

Ähnlich wie bei der run()-Methode, werden wir nun die paint()-Methode bearbeiten. Falls der Tod eintritt, werden wir ein entsprechendes Bild ausgeben.

Damit haben wir nun den Tod unseres Roboters eingebaut. Nun müssen wir noch ein Gesundheitssystem für unseren Roboter einbauen. Falls ihr etwas üben wollt, erstellt eine Methode, welche den Neustart des Spiels initialisiert oder aber ihr wartet bis wir das Spiel auf Android portiert haben.

Tipps:

  • Setzt jede Variable auf ihren Ausgangswert zurück, wie zu Beginn des Spiels
  • Erstellt eine Methode die alle benötigten Methoden aufruft, dass das Spiel wieder läuft.
  • Erstellt ein IF Statement, dass das Spiel neustartet nur nach einer gewissen Tastenkombination und nur wenn der Roboter auch Tod ist.

Gesundheitssystem des Gegners

 1. Erstellen des Gesundheitssystems

Dazu öffnen wir als erstes die Enemy Klasse. Als wir diese Klasse erstellt haben, haben wir maxHealth und currentHealth als Variable deklariert. Diese beiden Variablen löschen wir nun, genauso wie die dazugehörigen Getters and Setters, dies sollten 4 insgesamt sein. Zum Schluss fügen wir eine neue Variable mit dem Namen health ein und geben ihr den Wert von 5.

 

2. Schaden und Tod des Heliboys

Hierzu öffnen wir die Projectile Klasse. Wir werden das Gesundheitssystem nun dazu verwenden mit dem Schaden und dem Tod des Heliboys umzugehen.

Wenn wir dieses Spiel auf Android portieren, werden wir wesentlich mehr Gegner einfügen. Dies werden wir dann mit einer ArrayList tun. Da wir momentan nur 2 Gegner haben, müssen wir dies für beide einzeln tun.

Alle Änderungen werden in der checkCollision()-Methode der Projectile Klasse statt finden. Unser Ziel ist recht simpel. Wenn die Gesundheit größer 0 ist, subtrahiere 1. Wenn die Gesundheit 0 ist, stirbt der Heliboy und wird vom Bildschirm entfernt.

Wenn wir diese Änderungen vorgenommen haben, bekommen wir folgendes Resultat im Spiel.

2

Wie ihr sehen könnt oder auch nicht, ist der erste Heliboy verschwunden und es wurden 5 Punkte hinzugefügt. Unser Spiel beinhaltet noch einige Fehler, diese werden wir aber ausmerzen, wenn wir unser Spiel auf Android portiert haben. In der nächsten Lektion werden wir uns mit künstlicher Intelligenz beschäftigen und diese in unser Spiel einfügen.

Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.

Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, Danke sehr. Oder ein Klick auf die Werbung, hilft dabei diese Seite am laufen zu halten.

Source Code

Falls einer hier einsteigen möchte oder nicht den ganzen Code abtippen möchte, habe ich hier das Projekt exportiert und ihr könnt diesen bei euch einfügen. Unter der Kategorie Eclipse und Import und Export habe ich erläutert wie ihr dies macht.

Kapitel 3 Lektion 8

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 7 – Kollisionserkennung Teil 3 Lektion 9 – Künstliche Intelligenz

Feb 252013
 

Heute werden wir den letzten Teil der Kollisionserkennung behandeln. Dabei geht es um 2 Arten. Als erstes werden wir implementieren, dass unsere Kugeln den Gegner treffen und als zweites, ob unserer Roboter mit dem Heliboy kollidiert. Wir werden auch ein Punktesystem einführen, immer wenn wir den Gegner treffen, bekommen wir einen Punkt.

Kugel Kollision

1

Die Kugeln, welche wir in Kapitel 2 Lektion 7 erstellt haben, sind Rechtecke. Aus diesem Grund ist die Kollisionserkennung auch recht einfach zu implementieren.

Folgendermaßen werden wir vorgehen:

1. Wir werden jede Kugel ein Rechteck hinzufügen, dazu nehmen wir die projectiles ArrayList zur Hilfe.

2. Wir werden um unsere beiden Heliboys ein Rechteck legen. Da wir hier noch keine ArrayList haben, werden wir es einzeln machen. Wenn wir im nächsten Kapitel endlich für Android programmieren, werden wir die Enemy Klasse neu schreiben.

3. Solange die Kugeln auf dem Bildschirm angezeigt werden, also innerhalb von 800 sind, werden diese Rechtecke auf Kollisionen überprüft.

4. Falls eine Kollision auftritt, verschwinden die Kugeln.

 1. Erstellen eines rechteckigen Objekts

Dazu müssen wir einige Änderungen an unserer Projectile Klasse vornehmen. All diese Änderungen haben wir schon in den vorherigen Lektionen abgearbeitet, daher werde ich nur eine kurze Liste und die vollständige Klasse hier aufführen.

  • Rechtecke importieren
  • ein neues Rechteck bei den Variablen erstellen
  • das Rechteck im Konstrukteur aufrufen
  • das Rechteck immer wieder aktualisieren in der update()-Methode
  • wir setzen das Rechteck als 0, wenn die Kugel verschwindet
  • die checkCollision()-Methode aufrufen, wenn eine Kollision auftritt
  • einen Punkt hinzufügen für jede Kollision mit einem Gegner

 Projectiles Klasse

  beheben der Fehler

Wenn wir nun diese Änderungen vorgenommen haben, bekommen wir einige Fehler angezeigt. Diese Fehler spielen sich alle in der StartingClass ab, also öffnen wir nun diese.

1. Der erste Fehler liegt damit zusammen, dass hb und hb2 momentan als private deklariert sind. Daher werden wir sie nun als public um deklarieren.

2. Der nächste Fehler hat mit unserem Punktesystem zu tun, da wir dieses noch nicht erstellt haben, tun wir dies nun.

Als erstes erstellen wir die folgenden Variablen:

Damit erstellen wir eine Variable, welche unsere Punkte beinhaltet. Als nächstes haben wir ein Font Objekt erstellt, mit welchem wir unsere Punkte anzeigen.

Als zweites fügen wir den folgenden Code zur paint()-Methode hinzu:

Die erste Zeile des Codes setzt die Schriftart unserer graphischen Variable g zu font, welche wir voher als BOLD und Größe 30 deklariert haben.  Daher müssen wir noch Font importieren. Als nächstes haben wir die Farbe weiß ausgewählt, damit wird alles was nach dieser Zeile ausgeführt wird in weiß dargestellt, nur in der paint()-Methode. Mit der letzten Zeile lassen wir unsere Punkte, mit einem integeren String Objekt, anzeigen. Dies geschieht bei (740, 30). Damit sind wir am Ende der StartingClass und können diese schließen, hier nochmal die komplette Klasse:

ein Rechteck über die Gegner legen

Wir haben immer noch einige Fehler in unser Projectile Klasse. Daher werden wir nun die Enemy Klasse öffnen und ein paar Änderungen am Code vornehmen.

Wir haben unsere Heliboy Objekte erstellt, indem wir die Enemy Klasse als Superklasse deklariert haben und uns den Code von da besorgen. Wenn wir nun Änderungen an der Enemy Klasse vornehmen, ist unser Heliboy Objekt direkt davon betroffen.

Das Ziel ist nun, jedem Gegner ein Rechteck zu verpassen. Genau wie bei den Feldern, werden wir nur innerhalb der 25 Felder, die um unseren Roboter herum sind, ob hier eine Kollision stattfindet. Wenn nun irgendein Teil unseres Roboters rect, rect2, rect3 und rect4 einen Gegner berührt, werden wir Kollision auf dem Bildschirm, in diesem Fall in der Console in Eclipse, ausgeben.

Dazu müssen wir 3 Änderungen am Code vornehmen:

1. Ein Rechteck Objekt mit dem Namen r erstellen.

2. Die Rechtecke in der update()-Methode aktualisieren.

3. Eine checkCollision()-Methode erstellen.

Damit sind wir schon am Ende dieser Lektion. Wir haben ein Punktesystem eingeführt und können unsere Gegner abschießen und bei einer Kollision mit dem Gegner wird dies angezeigt. In der nächsten Lektion werden wir noch ein Gesundheitssystem einführen und den Tod des Roboters.

Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.

Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, Danke sehr. Oder ein Klick auf die Werbung, hilft dabei diese Seite am laufen zu halten.

Source Code

Falls einer hier einsteigen möchte oder nicht den ganzen Code abtippen möchte, habe ich hier das Projekt exportiert und ihr könnt diesen bei euch einfügen. Unter der Kategorie Eclipse und Import und Export habe ich erläutert wie ihr dies macht.

Kapitel 3 Lektion 7

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 6 – Kollisionserkennung Teil 2 Lektion 8 – Gesundheitssystem

Feb 212013
 

In der letzten Lektion haben wir uns um das gelbe und das orange Rechteck gekümmert:

1

Nun werden wir uns um die Hände kümmern und hier auch gleich beide Arten, also vertikal und horizontal, programmieren. Aber bevor wir damit beginnen, lasst uns erst nochmal darüber reden, wie wir das genau anstellen wollen.

Für unseren Zweck müssen wir zwei Sachen überprüfen. Als Erstes müssen wir feststellen, ob der Roboter in der Luft oder am Boden ist, und als zweites, welches Rechteck eine Kollision hat.

Wenn wir nun in der Luft sind und auf den Boden zurück fallen, wollen wir nicht, dass unsere Hände mit irgendetwas kollidieren. Darum geben wir vor, dass wir dabei keine ausgestreckten Hände haben, sie also gar nicht existieren. Dies gibt uns aber wieder ein Problem, wenn wir auf dem Boden sind und die Hände mit etwas Kollidieren. Daher müssen wir uns darum auch kümmern.

Wenn wir uns auf dem Boden befinden, die geduckte Haltung ist hier komplett außen vor, wollen wir, dass als Erstes überprüft wird, ob die Arme mit etwas Kollidieren. Danach soll der Körper überprüft werden. Je nach Höhe unserer Plattformen wird die Kollision angezeigt. So muss nicht nach einer Kollision des Körpers geschaut werden, wenn die Hände schon kollidieren.

Nun, da wir uns eine Strategie ausgelegt haben, können wir beginnen. Versucht dies auch zu verinnerlichen, während wir programmieren. Alles ergibt einen Sinn, wenn wir die Strategie verstehen.

Seitliche Kollisionserkennung

Wir gehen nun fast genauso vor wie bei der Erstellung der beiden großen Rechtecke.

Erstellen der Rechtecke

Um die Rechtecke zu erstellen, öffnen wir die Robot Klasse und fügen diese hinzu. Wir werden für die linke Hand rect3 und für die rechte rect4 verwenden.

Als Nächstes müssen wir die Position der Rechtecke immer wieder neu anpassen, wenn sich unser Roboter bewegt. Dazu fügen wir den folgenden Code zur update()-Methode hinzu.

Wer gerne möchte, kann die beiden Rechtecke noch zeichnen lassen, dies ist nicht zwingend erforderlich. Dazu gehen wir in die paint()-Methode der StartingClass Klasse.

Wann soll nach Kollisionen geschaut werden?

In der letzten Lektion haben wir in der update()-Methode der Robot Klasse folgendes Statement geschrieben:

if (true)

Damit wird immer und überall nach Kollisionen geschaut. Das ist aber natürlich so nicht richtig und auch nicht Sinn vom Programmieren. Wir wollen nur, dass das Programm in der näheren Umgebung des Roboters nach Kollisionen schaut. Dazu nehmen wir nur diese 25 Felder:

1

Nun müssen wir unsere Statements mit diesen 25 Feldern ersetzen. Dazu müssen wir alle tileX Werte dieser 25 Felder nehmen, die unter den roten Balken gehören und alle Werte von tileY, die innerhalb des gelben Balkens liegen.

2 3

 

Also werden wir nun noch ein rotes Rechteck für die Breite und ein gelbes Rechteck für die Höhe erstellen. Alle Felder, die nun innerhalb dieser Abmessung sind, werden auf Kollisionen geprüft.

Erstellen des roten und des gelben Rechtecks

Dazu müssen wir nur zwei Änderungen an der Robot Klasse vornehmen.

Falls ihr dieses Rechteck nun auch ausgeben wollt, nehmt folgende Ergänzung an der paint()-Methode in der StartingClass Klasse vor.

Kollisionserkennung

Dazu müssen wir als Erstes die Tile Klasse öffnen. Mit dem Erstellen des roten und des gelben Rechtecks können wir nun den entsprechenden Code dem Programm hinzufügen. Dazu ändern wir den Konstrukteur wie folgt:

Damit stellen wir sicher, dass die leeren Felder nicht mit dem Roboter kollidieren. Diese Änderung haben wir auch schon in der letzten Lektion vorgenommen.

Wenn wir das getan haben, müssen wir die update()-Methode anpassen. Die Fehler die entstehen, werden wir gleich korrigieren. Wir programmieren nun, dass nur unsere 25 Felder nach Kollisionen überprüft werden.

Fehlerbehebung

Diese Änderungen haben nun zu einigen Fehlern in unserem Code geführt. Als Erstes fangen wir mit den footleft, footright Fehlern an.

Wir öffnen die Robot Klasse und erstellen zwei neue Variablen.

Nun gehen wir in die update()-Methode und fügen diese zwei neuen Rechtecke auch dort ein.

Diese zwei Rechtecke sind für die seitlichen Kollisionen da. Wir benutzen sie, wenn unsere Felder niedriger als die Arme sind. Die Rechtecke sind ein wenig neben unseren Füßen platziert und stehen dadurch etwas raus.

Nun müssen wir unsere oben erwähnten zwei Methoden noch einfügen. Dazu öffnen wir die Tile Klasse und nehmen folgende Änderungen bzw. Ergänzungen vor.

Wie ihr sicherlich bemerkt habt, sind in diesen beiden Methoden zahlreiche checks/tests enthalten. Bitte schaut euch diesen Code sehr genau an, bis ihr jeden Teil auch versteht.

Letzte Änderungen

Nun müssen wir noch eine kleine Änderung in der Robot Klasse vornehmen. Da wir nun das Fallen in unserem Kollisionscode überprüfen, können wir den Teil der update()-Methode ändern, wo wir das Springen programmiert haben.

Als Letzes können wir ohne Probleme noch unsere Rechtecke aus der paint()-Methode der StartingClass entfernen, da wir diese Anzeige nicht mehr benötigen.

Wenn ihr nun unser Spiel startet, habt ihr eine komplette Kollisionserkennung für den Roboter. Spielt ein wenig , aber passt auf die Schluchten auf. In der nächsten Lektion kümmern wir uns um unseren Heliboy.

Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.

Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, danke sehr. Auch ein Klick auf die Werbung hilft dabei, diese Seite am Laufen zu halten.

Source Code

Für diejenigen unter euch, die hier einsteigen möchten, ohne den ganzen Code abtippen zu müssen, habe ich das Projekt exportiert. Mit der Importfunktion könnt ihr das Projekt bequem bei euch einfügen. Unter der Kategorie Eclipse und Java > Import und Export habe ich erklärt, was dafür zu tun ist.

Kapitel 3 Lektion 6

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 5 – Kollisionserkennung Teil 1 Lektion 7 – Kollisionserkennung Teil 3

Feb 212013
 

Da wir nun alle ein grundlegendes Verständnis von Kollisionen haben, können wir damit beginnen, diese in unser Spiel zu implementieren. In den nächsten Lektionen werden wir einige der angesprochenen Methoden genauer diskutieren. Da dies aber zum Einstieg in die Programmierung dient, werden wir keine komplexen Systeme behandeln. Dies werden wir gegebenenfalls zu einem späteren Zeitpunkt tun.

Begrenzungsrechtecke

In der vorhergehenden Lektion haben wir umhüllende Konturen kennengelernt, welche zur Kollisionserkennung benutzt werden. Für unseren Roboter werden wir vier umhüllende Rechtecke benutzen, wie an der Grafik unten zu sehen ist.

Heute werden wir nur die vertikalen Kollisionen behandeln und dabei werden wir uns nur mit dem gelben und dem orangen Rechteck beschäftigen.

1

Java besitzt schon eine implementierte Klasse, welche mit Rechtecken arbeiten kann, daher werden wir diese importieren. Wir werden die oben gezeigten Rechtecke darauf überprüfen, ob sie mit den in Lektion 3 gezeichneten Feldern kollidieren.

Kollisionserkennung ist eigentlich nur die Überprüfung, ob sich zwei Objekte überlappen oder eben nicht. Des Weiteren wird die Position eines der beiden Objekte angepasst auf einen Punkt, wo es keine Überlappung mehr gibt. Und dies sollte geschehen, bevor das Spiel etwas Falsches darstellt.

Und wie zeichnen wir nun das gelbe und das orange Rechteck?

In unserer Roboter Klasse müssen wir die folgenden Variablen hinzufügen:

Damit erzeugen wir zwei Objekte, hier Rechtecke, mit den Namen rect und rect2. Dazu nutzen wir (X, Y, Breite und Höhe) und wir müssen noch Rectangles (Rechtecke) importieren, am einfachsten mit STRG + Shift + O.

Als Nächstes gehen wir in die update()-Methode und fügen zwei Zeilen hinzu, welche bewirken, dass die Rechtecke beim Bewegen des Roboters immer wieder neu gezeichnet werden.

Am Anfang ist es sinnvoller, die Rechtecke zeichnen zu lassen, damit wir uns alles vorstellen können. Daher gehen wir nun in die StartingClass Klasse und ändern die paint()-Methode wie folgt.

Damit haben wir diesen Stand:

2

Es kann sein, dass bei einigen von euch Fehler auftreten und ihr daher das Spiel nicht starten könnt. Einer kann in der Robot Klasse sein, hier ist noch ein Getter and Setter vom Ground vorhanden. Den können wir einfach löschen. Ein Weiterer könnte in der StartingClass Klasse sein. Hier nutzen wir einfach die Hilfe von Eclipse und das Problem ist gelöst. Damit müsste jeder das Beispiel sehen.

Kollisionserkennung

Nun, da wir diese beiden Rechtecke gezeichnet haben, müssen wir überprüfen, ob sie mit den von uns gezeichneten Feldern kollidieren. Dazu öffnen wir die Tile Klasse.

Wie bei unserem Roboter müssen unsere gezeichneten Felder auch ein Rechteck bekommen. Dies ist recht einfach. Dazu müssen wir nur ein Rechteck im Tile Konstrukteur zeichnen lassen und in der update()-Methode immer wieder neu anpassen.

1. Wir erstellen eine neue Variable. Das r repräsentiert die Grenzen unseres Rechtecks. Wenn wir nun ein neues Feld erstellen, wird diesem automatisch ein Rechteck zugewiesen.

2. Danach müssen wir eine neue Methode erstellen, welche nach Kollisionen Ausschau hält. Daher werden wir am Ende der Klasse die folgenden Methode erstellen, welche einfach zwei Rechtecke nimmt und ein entsprechende Reaktion ausgibt.

3. Nun müssen wir diese noch in der update()-Methode aufrufen und wir müssen die Rechtecke immer wieder neu anpassen.

4. Als Letztes müssen wir noch sichergehen, dass unser Roboter nicht mit den leeren Feldern kollidiert. Um dies zu erreichen, müssen wir eine kleine Anpassung am Konstrukteur vornehmen.