Das ABC der Android-Spieleentwicklung: Bereiten Sie die Leinwand vor

In Google Play sind 23 der 25 erfolgreichsten Anwendungen für Android-Telefone und -Tablets Spiele (zum Zeitpunkt dieses Schreibens). Daher ist es nur dann sinnvoll, wenn Sie sich im mobilen Bereich befinden oder darüber nachdenken, in den mobilen Bereich einzusteigen, in Betracht zu ziehen, Unterhaltungssoftware zu schreiben.

Selbst für einen erfahrenen Softwareentwickler kann das Codieren eines Spiels ein wenig entmutigend sein. Es ist nicht so, dass das Schreiben von Spielen schwieriger ist als das Entwickeln anderer Arten von Anwendungen, es ist einfach anders. Die Spielprogrammierung hat ihre eigenen Techniken, Paradigmen und Vokabeln - Sie werden Spieleentwickler über Sprites, Bildraten, Weltkoordinaten und pixelgenaue Kollisionserkennung sprechen hören.

Letztes Jahr, als ich zusammen mit meinem Sohn mein erstes Spiel schrieb, kämmte ich das Internet und die Foren nach einfachen Tutorials, die die Grundlagen abdeckten. Es gibt eine überwältigende Menge an Informationen, aber die Spielprogrammierung ist oft spezifisch für eine Plattform und / oder ein Tool. Ich habe beschlossen, eine Reihe für TechRepublic-Leser zu schreiben, die die Schlüsselkonzepte des Codierens von Spielen auf der Android-Plattform vorstellt und zu einem nahezu vollständigen Spiel führt, das die diskutierten Techniken demonstriert.

Dies ist der erste Beitrag in dieser fünfteiligen Reihe. Der Quellcode in jeder Rate baut auf dem des vorherigen Beitrags auf. Sie können jedem Tutorial folgen oder das Projekt herunterladen und direkt in Eclipse importieren. Wie beim Lernen müssen wir laufen, bevor wir fliegen können. Daher wird der Code am Ende von Teil 1 dieses Tutorials zwar ausgeführt, aber nicht besonders unterhaltsam. Fürchte dich niemals, es wird dort ankommen. In der Zwischenzeit finden Sie unten einen kleinen Einblick in das abgeschlossene Spiel.

Abbildung A.

Dies ist ein Screenshot unseres fertigen Spiels. Das Ziel ist es, den Schwung der Untertasse anzupassen, um zu vermeiden, dass der Asteroid sie in Stücke zerschmettert. Das Projekt ist zwar simpel, enthält jedoch alle wesentlichen Aspekte eines Videospiels: Leinwand, Sprites, Animation, Kollisionserkennung und Benutzereingaben.

Wenn Sie noch keine Android-Programmierung durchgeführt haben, ist das auch in Ordnung. Es gibt viele Tools zum Schreiben von Handyspielen, und in einem späteren Beitrag werde ich einige der Alternativen diskutieren. Ich habe zwei Hauptgründe für die Wahl der Android-Leinwand und des Standard-SDK. Erstens sind die Techniken nicht so kompliziert, dass sie einen Neuling abschrecken. (Während OPENGL leistungsfähiger ist, reicht es oft aus, nur etwas auf dem Bildschirm anzuzeigen, um die Seele eines angehenden Spieleentwicklers zu zerstören.) Zweitens sind alle Tools kostenlos und können unter Mac OS, Linux und Microsoft heruntergeladen und eingerichtet werden Windows. Ich bin ein großer Fan von Corona SDK und Unity, aber beide kosten Geld, um loszulegen und laufen nur unter bestimmten Betriebssystemen.

Wenn Sie zum ersten Mal den Android App Builder-Blog von TechRepublic lesen, haben wir einen Leitfaden für Neulinge zur Android-Entwicklung. Sie sollten sich auch die offizielle Dokumentation von Google ansehen, um Ihre Entwicklungsumgebung zu installieren und einzurichten.

Leinwand vorbereiten

1. Erstellen Sie ein neues Android-Projekt in Eclipse. Da wir später einige der Gestenerkennungseingänge verwenden werden, die nicht Teil des 1.0 SDK waren, möchten wir sicherstellen, dass die Mindestversion von Android 2.1 (Eclair) oder besser ist. Denken Sie daran, Ihre Startaktivität in Main.java und das entsprechende Layout in main.xml umzubenennen.

2. Ändern Sie die Datei AndroidManifest.XML. Insbesondere werden wir unserer Aktivität eine Eigenschaft hinzufügen, die dazu führt, dass das Gerät Orientierungsänderungen ignoriert und den Bildschirm immer in den Hochformatmodus versetzt.

AndroidManifest.XML

 "http://schemas.android.com/apk/res/android" 
 package = "com.authorwjf.gamedevtut" 
 android: versionCode = "1" 
 android: versionName = "1.0" > 
 android: minSdkVersion = "8" 
 android: targetSdkVersion = "15" /> 
 android: icon = "@ drawable / ic_launcher" 
 android: label = "@ string / app_name" 
 android: theme = "@ style / AppTheme" > 
 android: screenOrientation = "Porträt" android: configChanges = "Ausrichtung | Tastatur versteckt " 
 android: name = ".Main" 
 android: label = "@ string / title_activity_main" > 
 "android.intent.action.MAIN" /> 
 "android.intent.category.LAUNCHER" /> 

3. Definieren Sie das Layout für unsere Anwendung. Suchen Sie im Ordner / res / layout nach main.xml. Wenn Sie Android programmiert haben, sollten Sie zum größten Teil die Layoutkomponenten erkennen. Ich habe mit einer Ausnahme ein lineares Standardlayout mit gängigen Android-UI-Widgets erstellt. Beachten Sie, dass das allerletzte Element im Layout als GameBoard definiert ist. Dies ist unsere eigene Ansicht und das Herzstück des Zeichnens unseres Spiels auf den Bildschirm. Im Moment sollten Sie sicherstellen, dass Sie auf Ihr Paket verweisen, wenn Sie nicht denselben Paketnamen wie ich verwendet haben (com.authorwjf.drawing).

main.xml

 "http://schemas.android.com/apk/res/android" 
 android: layout_width = "fill_parent" 
 android: layout_height = "fill_parent" 
 android: orientierung = "vertikal" > 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "top | center" 
 android: text = "ABC's von Android Game Dev" /> 
 android: id = "@ + id / the_button" 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 Android: Schwerkraft = "Zentrum" 
 android: enabled = "false" 
 android: text = "Zurücksetzen" /> 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 android: text = "Sprite-Geschwindigkeit (?, ?)" 
 android: id = "@ + id / the_label" /> 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 android: text = "Letzte Kollision XY (?, ?)" 
 android: id = "@ + id / the_other_label" /> 
 android: layout_width = "fill_parent" 
 android: layout_height = "fill_parent" 
 android: layout_margin = "20dip" 
 android: id = "@ + id / the_canvas" /> 

4. Wechseln Sie in unser Verzeichnis / src und erstellen Sie ein neues .drawing-Paket. In meinem Fall ist das Paket com.authorwjf.drawing. Fügen Sie in diesem Paket eine neue Klassendatei hinzu und nennen Sie sie GameBoard.java. Diese neue Klassendatei verarbeitet die gesamte Zeichnung auf unserer Leinwand. In seiner ersten Inkarnation malt GameBoard.java einfach einen schwarzen Hintergrund und füllt ein Sternfeld mit zufälligen pulsierenden Sternen.

GameBoard.java

 Paket com.authorwjf.drawing; 
 import java.util.ArrayList; 
 import java.util.List; 
 import java.util.Random; 
 android.content.Context importieren ; 
 android.graphics.Canvas importieren ; 
 android.graphics.Color importieren ; 
 android.graphics.Paint importieren ; 
 android.graphics.Point importieren ; 
 import android.util.AttributeSet; 
 android.view.View importieren ; 
 public class GameBoard erweitert View { 
 Privatfarbe p; 
 private Liste starField = null ; 
 private int starAlpha = 80; 
 private int starFade = 2; 
 private static final int NUM_OF_STARS = 25; 
 synchronisierte öffentliche Leere resetStarField () { 
 starField = null ; 
 }} 
 öffentliches GameBoard (Kontextkontext, AttributeSet aSet) { 
 super (Kontext, aSet); 
 // Es ist am besten, keine neuen Objekte im On Draw zu erstellen 
 // initialisiere sie hier als Klassenvariablen 
 p = neue Farbe (); 
 }} 
 private void initializeStars ( int maxX, int maxY) { 
 starField = new ArrayList (); 
 für ( int i = 0; i < NUM_OF_STARS ; i ++) { 
 Random r = new Random (); 
 int x = r.nextInt (maxX-5 + 1) +5; 
 int y = r.nextInt (maxY-5 + 1) +5; 
 starField.add ( neuer Punkt (x, y)); 
 }} 
 }} 
 @Override 
 synchronisierte öffentliche Leere onDraw (Canvas Canvas) { 
 // Erstelle eine schwarze Leinwand 
 p.setColor (Farbe. SCHWARZ ); 
 p.setAlpha (255); 
 p.setStrokeWidth (1); 
 canvas.drawRect (0, 0, getWidth (), getHeight (), p); 
 // Initialisiere das Sternenfeld bei Bedarf 
 if (starField == null ) { 
 initializeStars (canvas.getWidth (), canvas.getHeight ()); 
 }} 
 // zeichne die Sterne 
 p.setColor (Farbe. CYAN ); 
 p.setAlpha (starAlpha + = starFade); 
 // blende sie ein und aus 
 if (starAlpha> = 252 || starAlpha <= 80) starFade = starFade * -1; 
 p.setStrokeWidth (5); 
 für ( int i = 0; i < NUM_OF_STARS ; i ++) { 
 canvas.drawPoint (starField.get (i) .x, starField.get (i) .y, p); 
 }} 
 }} 
 }} 

5. Ändern Sie die Datei /src/Main.java. In der Hauptklassendatei werden die Koordinaten aller Benutzerobjekte aktualisiert, die von der GameBoard-Klasse auf den Bildschirm gezeichnet werden, wobei Benutzereingaben und die Bildrate verarbeitet werden. Durch das regelmäßige Posten einer Ungültigmachung auf der Zeichenfläche zwingt Main.java die Zeichenfläche, ihren Inhalt neu zu zeichnen, um alle Aktualisierungen in der Aktion widerzuspiegeln. Stellen Sie sich Main.java als das Gehirn hinter unserem Spiel vor.

Main.java

 Paket com.authorwjf.gamedevtut; 
 import com.authorwjf.drawing.GameBoard; 
 import com.authorwjf.gamedevtut.R; 
 import android.os.Bundle; 
 import android.os.Handler; 
 android.app.Activity importieren ; 
 android.view.View importieren ; 
 android.view.View.OnClickListener importieren ; 
 android.widget.Button importieren ; 
 public class Main erweitert Activity implementiert OnClickListener { 
 privater Handler-Frame = neuer Handler (); 
 // Teilen Sie den Frame durch 1000, um zu berechnen, wie oft pro Sekunde der Bildschirm aktualisiert wird. 
 private static final int FRAME_RATE = 20; // 50 Bilder pro Sekunde 
 @Override 
 public void onCreate (Bundle savedInstanceState) { 
 super .onCreate (savedInstanceState); 
 setContentView (R.layout. main ); 
 Handler h = neuer Handler (); 
 ((Button) findViewById (R.id. the_button )). SetOnClickListener ( this ); 
 // Wir können die Grafiken nicht sofort initialisieren, da der Layout-Manager 
 // muss zuerst ausgeführt werden, daher rufen wir in einer Sekunde zurück. 
 h.postDelayed ( new Runnable () { 
 @Override 
 public void run () { 
 initGfx (); 
 }} 
 }, 1000); 
 }} 
 synchronisierte öffentliche Leere initGfx () { 
 ((GameBoard) findViewById (R.id. the_canvas )). ResetStarField (); 
 ((Button) findViewById (R.id. the_button )). SetEnabled ( true ); 
 // Es ist eine gute Idee, vorhandene Rückrufe zu entfernen, um sie beizubehalten 
 // sie vor versehentlichem Stapeln. 
 frame.removeCallbacks (frameUpdate); 
 frame.postDelayed (frameUpdate, FRAME_RATE ); 
 }} 
 @Override 
 synchronisierte öffentliche Leere onClick (View v) { 
 initGfx (); 
 }} 
 private Runnable frameUpdate = new Runnable () { 
 @Override 
 synchronisierter öffentlicher void run () { 
 frame.removeCallbacks (frameUpdate); 
 // hier Aktualisierungen an Bildschirmobjekten vornehmen 
 // Rufe dann den On Draw auf, indem du die Zeichenfläche ungültig machst 
 ((GameBoard) findViewById (R.id. the_canvas )). Invalidate (); 
 frame.postDelayed (frameUpdate, FRAME_RATE ); 
 }} 
 }; 
 }} 

Das Projekt sollte zum Kompilieren und Laden auf Ihr Gerät oder Ihren Emulator bereit sein. Es wird unser Sternfeld zeichnen und die Sterne rein und raus pulsieren lassen. Durch Drücken der Reset-Taste wählt die App neue Zufallskoordinaten für die Sterne aus. Wenn Sie nicht viel Erfahrung mit der Android-Entwicklung haben, ist der Simulator schmerzhaft langsam. Machen Sie sich also keine Sorgen, wenn der animierte Effekt der Sterne nicht so bissig ist, wie Sie möchten. Führen Sie es auf einem tatsächlichen Telefon aus, und ich denke, Sie werden mit den Ergebnissen zufrieden sein.

Kehren Sie zum Android App Builder-Blog für Teil zwei dieser Serie zurück, in dem es um Sprites geht.

© Copyright 2021 | pepebotifarra.com