Jan 222013
 

Heute werden wir uns mit Animationen beschäftigen, was viel neuen Code bedeutet. Theoretisch sind Animationen recht einfach. Alles was ihr dazu benötigt, ist eine Folge von Bildern, welche wir künftig als Frames bezeichnen, und die Dauer bzw. Zeitspanne, wie lange jedes dieser Bilder angezeigt wird. Als nächstes müssen wir nur noch den aktuellen Frame der Sequenz für die gewünschte Zeitspanne anzeigen.

In Wirklichkeit bedeutet dies leider etwas mehr Arbeit, also lasst uns damit beginnen.

Stunde #2-24: Erstellen der Animation-Klasse

Wie immer werden wir einen Entwurf bzw. Plan für alle Animationen erstellen, die wir entwickeln werden. Diese Klasse wird aber etwas anders als die, die wir bisher kennen (ihr werdet eine verschachtelte Klasse kennen lernen).

Tipp: Die Animation-Klasse kann immer und immer wieder verwendet werden (mit bestimmten Modifikationen). Darum nennen wir dies auch Framework (Rahmen oder Gerüst), weil es sich im Wesentlichen um wiederverwendbaren Code handelt, der uns auch bei künftigen Projekten nützlich sein kann.

I. Erstellen eines Pakets und der Animation-Klasse

Als erstes erstellen wir ein neues Paket, dies hilft uns dabei, ein wenig Ordnung zu halten.

1. Rechtsklick auf src, danach New > Package auswählen.

2. Wir nennen es basteldroid.framework

1

3. Rechtsklickt auf basteldroid.framework und erstellt eine neue Klasse namens Animation.

Was benötigen wir alles in dieser Klasse?

1. Wir benötigen Variablen für Folgendes: Frames, aktueller Frame, Animationszeit und komplette Zeit.

2. Wir müssen einen Konstrukteur erstellen.

3. Eine Methode die

  • einen Frame zur neuen Animation hinzufügt
  • den aktuellen Frame mit dem richtigen Bild aktualisiert
  • den richtigen Frame ausgibt, so dass wir diesen in der StartingClass ausgeben können
  • den richtigen Frame Index ausgibt

4. Wir erstellen eine Klasse in der Klasse namens AnimFrame, welches dazu benutzt wird, Objekte zu erzeugen, welche das aktuelle Bild und dessen Anzeigedauer beinhalten.

Wir werden jedes Einzelne genauer beleuchten, wenn wir dies implementieren.

II. Definieren der Animationsklasse

Momentan solltet ihr nur eine leere Klasse haben:

1. Variablen

Nun werden wir die folgenden Variablen hinzufügen und die entsprechenden Pakete importieren:

  •  ArrayList frames werden die AnimFrame, welche wir später erstellen, mit folgenden Werten beinhalten: Bild und Anzeigedauer
  • currentFrame beinhaltet den Index unserer ArrayList, den Platz in der Liste, welche mit 0 beginnt
  • animTime controlliert, wie lange das aktuelle Bild angezeigt wurde und sobald eine gewisse Zeit erreicht ist, wird ein neues Bild angezeigt
  • totalDuration bezieht sich auf die Zeit, die jedes Bild angezeigt wird

Beispiel:

Stellen wir uns vor, wir haben eine ArrayList namens frames und diese beinhaltet das Folgende:

AnimFrame(Bild1, 100);
AnimFrame(Bild2, 200);
AnimFrame(Bild3, 400);
AnimFrame(Bild2, 200);
AnimFrame(Bild1, 100);

  • Diese Gruppe von AnimFrame Objekten bezeichnen wir als frame ArrayList.
  • currentFrame: nehmen wir an, Bild3 wird gerade angezeigt, dies bedeutet, dass wir bei Index 2 sind, die Liste beginnt bei 0
  • animTime: wird nun überprüfen, wie lange das Bild schon angezeigt wird
  • totalDuration: in diesem Fall ist die Anzeigedauer 400

2. Der Konstrukteur

Dieser wird sehr einfach, er ruft einfach die vier erzeugten Variablen auf.

Von diesem Code ist uns bisher nur synchronized neu, dies bedeutet Synchronisieren. Um es etwas verständlicher zu machen, müssen wir über Threads reden. Falls ihr nicht wisst, was das ist, schaut in Kapitel 1 Lektion 11 nach.

Wenn wir mehrere Threads haben, laufen diese technisch gesehen nicht immer simultan. Sie springen nur zwischen einander hin und her, wie bei einem Schalter.

Wenn wir nun synchronized benutzen, wird animTime und currentFrame immer zusammen aufgerufen. Falls wir dies nicht tun, könnte erst das eine, dann ein komplett anderer Thread und dann das andere aufgerufen werden. Das klingt jetzt vielleicht etwas verwirrend, aber wahrscheinlich erkennt ihr die Bedeutung dessen erst später. Zurzeit sollten wir es einfach so betrachten, dass es uns künftig das Programmieren erleichtert..

3. Methoden

Wir werden nun vier Methoden zu unserem Code hinzufügen.

  • addFrame()-Methode: Diese Methode nimmt ein AnimFrame und hängt es an die ArrayList namens frames. Auch hier werden wir synchronized nutzen.

  • update()-Methode: Was wir mit dieser Methode vor haben, sollte jedem klar sein. elapsedTime ist die Zeit, welche seit dem letzten Durchlaufen der Methode vergangen ist.

  • getImage()-Methode: Diese Methode gibt das Bild aus, welches zu currentFrame gehört. In dieser Methode benutzen wir Image anstelle von Void. Dies bedeutet, dass diese Methode einen Wert an die Methode zurück gibt, welche sie aufgerufen hat.

  • getFrame()-Methode: Hier lassen wir uns den aktuellen Frame ausgeben.

 4. Die Nested (geschachtelte) AnimFrame Klasse

Wir haben nun schon einige Male über AnimFrame Objekte gesprochen, aber wir haben noch keine Klasse angelegt, um diese zu erzeugen. Wir könnten nun eine neue Klasse erstellen und diese in der Animation-Klasse aufrufen. Einfacher ist es jedoch, diese direkt in der Animation-Klasse zu platzieren und genau das bedeutet nesting (eine Klasse in einer anderen Klasse schreiben).

Nun werden wir AnimFrame bearbeiten und alles Nötige mit STRG + Shift + O importieren:

Nun sollten wir alle den selben Stand haben:

Stunde #2-25: Animieren unserer Spielfiguren

Ladet die folgenden Bilder herunter und speichert sie in eurem Data Ordner:

character2 character3

heliboy5 heliboy2 heliboy3 heliboy4

Bitte überschreibt die Dateien heliboy.png und background.png mit den beiden Bildern. Ich hatte in der vorherigen Lektion eine falsche Datei eingefügt. Das neue Hintergrundbild ist für das Auge.

background heliboy

Wenn wir das getan haben, gehen wir auf Project > Clean > OK.

Nun haben wir unser Projekt etwas aufräumen lassen und gehen in die StartingClass. Um unsere neue Animationsklasse verwenden zu können, müssen wir diese erst importieren:

Das ist einer der Momente, wo alles plötzlich einen Sinn ergibt. Ihr habt schon eine Menge importiert, ohne zu wissen, wozu das eigentlich nötig ist, aber jetzt habt ihr zum ersten Mal eure eigene Klasse importiert. Nun solltet ihr verstehen, wie es wirklich funktioniert.

1. Bilder Variablen anpassen

Wir haben neue Bilder in unseren data Ordner kopiert. Um diese auch nutzen zu können, müssen wir sie als Variable deklarieren:

 2. Animationsobjekte erstellen

Um unseren Roboter zu animieren, benutzen wir anim und um den Heliboy zu animieren, benutzen wir hanim.

3. Bildeinstellungen

Nun müssen wir die von uns neu hinzugefügten Bilder initialisieren. Dazu werden wir Änderungen an der init()-Methode vornehmen. Wir werden die neuen Bilder ergänzen und anim und hanim, welche die Frames erstellen mit den jeweiligen Bildern und der Anzeigedauer.

 4. Aufrufen unserer Bilder

Um unsere neu erzeugten Animationen aufzurufen, müssen wir diese in der run()-Methode auch ändern. Wenn ihr vergleicht, was wir ändern und hinzufügen, sollte es sich selbst erklären.

 5. Animation

Wir erstellen eine animate()-Methode. Mit den Parametern, welche wir darin bestimmen, können wir leichter ändern, wie schnell unsere Figuren animiert werden. Je höher der Wert, desto schneller die Animation, passt diesen Wert je nach Belieben an. Schreibt diese Methode nach der run()-Methode.

6. Bildschirmausgabe

Um unsere neuen Animationen auch auf dem Bildschirm zu sehen, müssen wir die paint()-Methode entsprechend ändern. Dazu werden wir nur unsere beiden Heliboys in dieser Methode ändern, den Roboter haben wir schon in der run()-Methode bearbeitet.

Damit sind wir eigentlich am Ende dieser Lektion, ich muss aber noch einen Fehler aus der Lektion 5 klar stellen. Natürlich kann unser  Roboter auch springen, dazu braucht ihr einfach nur die Leertaste zu betätigen. Ich bin mir nicht ganz sicher, was mich dabei geritten hat, dass zu schreiben.

Heute haben wir es geschafft, dass sich die Rotorblätter unserer Helikopter drehen und unser Roboter blinzelt. Ich denke, das ist sehr gut für eine Lektion. Falls es noch etwas gibt, wo ihr nicht genau wisst, wie es funktioniert wie beispielsweise die Abfolge der Bilder, dann spielt einfach ein wenig mit dem Code oder stellt mir Fragen.

In der nächsten Lektion werden wir uns mit 2D-Feldern beschäftigen. Damit bereiten wir uns darauf vor, unsere eigenen Level zu erstellen. Wir werden dies in den nächsten beiden Lektionen lernen und schließen damit Kapitel 2 ab. Da ich in den nächsten Tagen im Ski-Urlaub bin, werden frühestens nächste Woche neue Lektionen veröffentlicht.

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 2 Lektion 8

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+, das würde dieser Seite wirklich weiterhelfen, danke sehr. Auch ein Klick auf die Werbung hilft dabei, diese Seite am Laufen zu halten.

 

Quelle: Original Anleitung auf englisch von Kilobolt Studios

Lektion 7 – Kugeln abfeuern Lektion 9 – 2D-Felder