Es ist nun schon einige Zeit her, dass ich das letzte mal eine Lektion veröffentlicht habe. Ich hatte kleine Schwierigkeiten mit meinem Code und konnte diese nicht lösen. Mittlerweile habe ich alle Probleme beseitigt und das Spiel läuft.
In dieser Lektion werden wir in 5 Schritten ein Android Spiel entwickeln, als Basis nehmen wir unser Roboter Spiel aus dem Kapitel 2 und 3. Obwohl ich euch zeige, wie ihr ein Spiel portiert, kann diese Anleitung auch dazu verwendet werden ein komplett neues Spiel zu programmieren.
Portieren kann so einfach sein!
Glücklicherweise kann fast der komplette Code, welchen wir in Kapitel 2 und 3 entwickelt haben, nach Android übersetzt werden. Das bedeutet wir können ihn einfach kopieren und einfügen. Ausnahmen bestätigen die Regel, hier ist es genauso. Die Rectangle Klasse zum Beispiel, aber das ist alles kein Problem. Wir haben neue Klassen die diese Aufgaben übernehmen.
Download des Gründgerüst
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.
Erstellen des Spiels und Umbenennung des Paketes
Wir haben nun die com.basteldroid.framework und das com.basteldroid.framework.implementation Pakete, hier werden wir nun noch ein weiteres Paket erstellen, dass com.basteldroid.robotgame. Falls ihr eure Pakete umbenennen wollt, geht das unter recht klick auf das Paket und Refactor –> Rename.
Wir haben nun den folgenden Stand:
1. Das Interface com.basteldroid.framework
2. Die Implementationen des Interface com.basteldroid.framework.implementation
3. Der Spiel Code com.basteldroid.robotgame
Spiel Entwicklung
Grundeinstellung
Als erstes öffnen wir die AndroidGame Klasse und ändern die Bildschirmauflösung, dazu wählen wir das folgende aus:
int frameBufferWidth = isPortrait? 480: 800;
int frameBufferHeight = isPortrait? 800: 480;
Denkt daran wofür das ? steht und was es damit auf sich hat!
Nun werden wir mit dem Programmieren beginnen. Denkt dran das unser Spiel nur eine Aktivität hat. Normalerweise haben Apps, immer wenn man eine neue Seite öffnet, auch eine neue Aktivität. Wir werden aber bei einer Aktivität bleiben, die immer wieder nur geändert wird. Daher haben wir es wesentlich einfacher mit der Integration von Musik, Dateien und und und.
Die folgenden Klassen benötigen wir:
Spiel Unabhängige Klassen (Erforderlich für die meisten Spiele, in diesem Framework erstellt)
Assets Klasse – ordnet Bezugsgrößen auf alle Assets (Bilder / Audio), die in unserem Spiel verwendet werden.
SplashLoadingScreen & LoadingScreen – Erstere wird verwendet, um das Hintergrundbild des Startbildschirms zu laden, und in der LoadingScreen werden wir dieses geladene Bild anzeigen, während wir jeden anderen Bild / Audio-Datei im Spiel laden.
Menu Screen – Gebraucht, um das Spiel zu starten.
Spielbildschirm – Hier wird sich das ganze Spiel abspielen, diese Klasse ist ähnlich der StartingPoint Klasse.
SampleGame – Die Aktivität-Klasse wird gestartet beim Start des Spiels und öffnet unsere App.
RobotGame Klassen (Kopiert aus den Kapiteln 2 und 3)
Animation
Background
Enemy
Heliboy
Projectile
Robot
Tile
Das sind nun alle Klassen, welche wir für unser Spiel benötigen. Als erstes benötigen wir aber noch ein paar Dateien.
Download der Dateien
Entpackt diese Datei und kopiert alles im assets Ordner in den dazugehörigen assets Ordner in eurem Projekt. Der raw Ordner wird direkt in den res Ordner kopiert. Dies muss genau so ausgeführt werden, da sonst unser Spiel abstürzt.
1. SampleGame Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
package com.basteldroid.robotgame; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import android.util.Log; import com.basteldroid.framework.Screen; import com.basteldroid.framework.implementation.AndroidGame; import com.basteldroid.robotgame.R; public class SampleGame extends AndroidGame { public static String map; boolean firstTimeCreate = true; @Override public Screen getInitScreen() { if (firstTimeCreate) { Assets.load(this); firstTimeCreate = false; } InputStream is = getResources().openRawResource(R.raw.map1); map = convertStreamToString(is); return new SplashLoadingScreen(this); } @Override public void onBackPressed() { getCurrentScreen().backButton(); } private static String convertStreamToString(InputStream is) { BufferedReader reader = new BufferedReader(new InputStreamReader(is)); StringBuilder sb = new StringBuilder(); String line = null; try { while ((line = reader.readLine()) != null) { sb.append((line + "\n")); } } catch (IOException e) { Log.w("LOG", e.getMessage()); } finally { try { is.close(); } catch (IOException e) { Log.w("LOG", e.getMessage()); } } return sb.toString(); } @Override public void onResume() { super.onResume(); Assets.theme.play(); } @Override public void onPause() { super.onPause(); Assets.theme.pause(); } } |
Diese SampleGame Klasse erweitert die AndroidGame Klasse , welche wiederum die Aktivität erweitert. Also haben wir hier eine Aktivität.
1. getInitScreen()-Methode überprüft, ob es das erste mal ist, dass diese Klasse geöffnet wir. Wenn es das erste Mal ist, die die Load()-Methode innerhalb der Assets Klasse aufgerufen, welche die Musik lädt. Dies erlaubt uns die Musik zu handhaben, ohne das wir mehrere Instanzen von Hintergrund Musik benötigen. Hier rufen wir auch unsere Mappe auf, die ihre Informationen aus der map1.txt zieht.
Danach werden wir auf den SplashLoadingScreen geschickt, der erste Bildschirm beim Start unseres Spiels, mehr dazu nachher.
2. onBackPressed()-Methode überschreibt die normale Aktion die passiert wenn der Zurück Button gedrückt wird. So das immer genau das geschieht, was wir hier programmieren.
3. convertStreamToString() hier wird die .txt Datei genommen und in eine String umgewandelt.
4. onResume() und onPause() diese beiden im Android Lebenszyklus aufgerufen. Falls ihr nicht mehr wisst, wofür diese da sind, geht bitte ein paar Lektionen zurück.
2. Assets Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package com.basteldroid.robotgame; import com.basteldroid.framework.Image; import com.basteldroid.framework.Music; import com.basteldroid.framework.Sound; public class Assets { public static Image menu, splash, background, character, character2, character3, heliboy, heliboy2, heliboy3, heliboy4, heliboy5; public static Image tiledirt, tilegrassTop, tilegrassBot, tilegrassLeft, tilegrassRight, characterJump, characterDown; public static Image button; public static Sound click; public static Music theme; public static void load(SampleGame sampleGame) { // TODO Auto-generated method stub theme = sampleGame.getAudio().createMusic("menutheme.mp3"); theme.setLooping(true); theme.setVolume(0.85f); theme.play(); } } |
Hier werden alle Assets geladen die unser Spiel benötigt und die Hintergrund mit einer Lautstärke von 85% abgespielt.
3. SplashLoadingScreen Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
package com.basteldroid.robotgame; import com.basteldroid.framework.Game; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Screen; import com.basteldroid.framework.Graphics.ImageFormat; public class SplashLoadingScreen extends Screen { public SplashLoadingScreen(Game game) { super(game); } @Override public void update(float deltaTime) { Graphics g = game.getGraphics(); Assets.splash= g.newImage("splash.jpg", ImageFormat.RGB565); game.setScreen(new LoadingScreen(game)); } @Override public void paint(float deltaTime) { } @Override public void pause() { } @Override public void resume() { } @Override public void dispose() { } @Override public void backButton() { } } |
Da dies eine Unterklasse der Screen Superklasse ist, müssen wir hier alle Screen Methoden aufrufen. Wir haben hier die update()-Methode, wo wir das erste Bild als RGB565 laden. Wisst ihr noch was das bedeutet? Wenn nun unser splash.jpg geladen ist, gehen wir direkt in die …
4. LoadingScreen Klasse
Diese Klasse ist fast die Selbe, wie die Klasse zuvor. Hier werden nur wesentlich mehr Bilder geladen. So lange es dauert, diese Bilder zu laden, solange wird die paint()-Methode ausgeführt und unser splash.jpg angezeigt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
package com.basteldroid.robotgame; import com.basteldroid.framework.Game; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Graphics.ImageFormat; import com.basteldroid.framework.Screen; public class LoadingScreen extends Screen { public LoadingScreen(Game game) { super(game); } @Override public void update(float deltaTime) { Graphics g = game.getGraphics(); Assets.menu = g.newImage("menu.png", ImageFormat.RGB565); Assets.background = g.newImage("background.png", ImageFormat.RGB565); Assets.character = g.newImage("character.png", ImageFormat.ARGB4444); Assets.character2 = g.newImage("character2.png", ImageFormat.ARGB4444); Assets.character3 = g.newImage("character3.png", ImageFormat.ARGB4444); Assets.characterJump = g.newImage("jumped.png", ImageFormat.ARGB4444); Assets.characterDown = g.newImage("down.png", ImageFormat.ARGB4444); Assets.heliboy = g.newImage("heliboy.png", ImageFormat.ARGB4444); Assets.heliboy2 = g.newImage("heliboy2.png", ImageFormat.ARGB4444); Assets.heliboy3 = g.newImage("heliboy3.png", ImageFormat.ARGB4444); Assets.heliboy4 = g.newImage("heliboy4.png", ImageFormat.ARGB4444); Assets.heliboy5 = g.newImage("heliboy5.png", ImageFormat.ARGB4444); Assets.tiledirt = g.newImage("tiledirt.png", ImageFormat.RGB565); Assets.tilegrassTop = g.newImage("tilegrasstop.png", ImageFormat.RGB565); Assets.tilegrassBot = g.newImage("tilegrassbot.png", ImageFormat.RGB565); Assets.tilegrassLeft = g.newImage("tilegrassleft.png", ImageFormat.RGB565); Assets.tilegrassRight = g.newImage("tilegrassright.png", ImageFormat.RGB565); Assets.button = g.newImage("button.jpg", ImageFormat.RGB565); //Falls ihr Sound installieren wollt, das geht wie folgt: //Assets.click = game.getAudio().createSound("explode.ogg"); game.setScreen(new MainMenuScreen(game)); } @Override public void paint(float deltaTime) { Graphics g = game.getGraphics(); g.drawImage(Assets.splash, 0, 0); } @Override public void pause() { } @Override public void resume() { } @Override public void dispose() { } @Override public void backButton() { } } |
Wenn das Laden fertig ist, wird die MainMenuScreen Klasse geöffnet. Wenn ihr mal genau schaut, ist die backButton()-Methode in den letzten beiden Klassen leer gewesen. Wir wollen nicht das der Benutzer hier auf zurück drückt und unseren Ladevorgang unterbricht, daher sind diese leer.
5. MainMenuScreen Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
package com.basteldroid.robotgame; import java.util.List; import com.basteldroid.framework.Game; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Screen; import com.basteldroid.framework.Input.TouchEvent; public class MainMenuScreen extends Screen { public MainMenuScreen(Game game) { super(game); } @Override public void update(float deltaTime) { Graphics g = game.getGraphics(); List touchEvents = game.getInput().getTouchEvents(); int len = touchEvents.size(); for (int i = 0; i < len; i++) { TouchEvent event = touchEvents.get(i); if (event.type == TouchEvent.TOUCH_UP) { if (inBounds(event, 50, 350, 250, 450)) { game.setScreen(new GameScreen(game)); } } } } private boolean inBounds(TouchEvent event, int x, int y, int width, int height) { if (event.x > x && event.x < x + width - 1 && event.y > y && event.y < y + height - 1) return true; else return false; } @Override public void paint(float deltaTime) { Graphics g = game.getGraphics(); g.drawImage(Assets.menu, 0, 0); } @Override public void pause() { } @Override public void resume() { } @Override public void dispose() { } @Override public void backButton() { android.os.Process.killProcess(android.os.Process.myPid()); } } |
In dieser Klasse zeigen wir das Menübild an. Wenn der Benutzer nun den Play Button drückt, öffnet sich die GameScreen Klasse. Wenn der Benutzer auf den Zurück Button drückt, wird das Spiel beendet.
6. GameScreen Klasse
Diese Klasse können wir mit der StartingClass aus dem Kapitel 2 und 3 vergleichen. Die Fehler ignorieren wir erst einmal.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 |
package com.basteldroid.robotgame; import java.util.ArrayList; import java.util.List; import java.util.Scanner; import android.graphics.Color; import android.graphics.Paint; import com.basteldroid.framework.Game; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Image; import com.basteldroid.framework.Input.TouchEvent; import com.basteldroid.framework.Screen; public class GameScreen extends Screen { enum GameState { Ready, Running, Paused, GameOver } GameState state = GameState.Ready; // Variablen Einstellungen private static Background bg1, bg2; private static Robot robot; public static Heliboy hb, hb2; private Image currentSprite, character, character2, character3, heliboy, heliboy2, heliboy3, heliboy4, heliboy5; private Animation anim, hanim; private ArrayList tilearray = new ArrayList(); int livesLeft = 1; Paint paint, paint2; public GameScreen(Game game) { super(game); // Spielobjekte werden hier initialisiert bg1 = new Background(0, 0); bg2 = new Background(2160, 0); robot = new Robot(); hb = new Heliboy(340, 360); hb2 = new Heliboy(700, 360); character = Assets.character; character2 = Assets.character2; character3 = Assets.character3; heliboy = Assets.heliboy; heliboy2 = Assets.heliboy2; heliboy3 = Assets.heliboy3; heliboy4 = Assets.heliboy4; heliboy5 = Assets.heliboy5; anim = new Animation(); anim.addFrame(character, 1250); anim.addFrame(character2, 50); anim.addFrame(character3, 50); anim.addFrame(character2, 50); hanim = new Animation(); hanim.addFrame(heliboy, 100); hanim.addFrame(heliboy2, 100); hanim.addFrame(heliboy3, 100); hanim.addFrame(heliboy4, 100); hanim.addFrame(heliboy5, 100); hanim.addFrame(heliboy4, 100); hanim.addFrame(heliboy3, 100); hanim.addFrame(heliboy2, 100); currentSprite = anim.getImage(); loadMap(); // Definieren der Objekte zum Zeichnen paint = new Paint(); paint.setTextSize(30); paint.setTextAlign(Paint.Align.CENTER); paint.setAntiAlias(true); paint.setColor(Color.WHITE); paint2 = new Paint(); paint2.setTextSize(100); paint2.setTextAlign(Paint.Align.CENTER); paint2.setAntiAlias(true); paint2.setColor(Color.WHITE); } private void loadMap() { ArrayList lines = new ArrayList(); int width = 0; int height = 0; Scanner scanner = new Scanner(SampleGame.map); while (scanner.hasNextLine()) { String line = scanner.nextLine(); // Keine weiteren Zeilen if (line == null) { break; } if (!line.startsWith("!")) { lines.add(line); width = Math.max(width, line.length()); } } height = lines.size(); for (int j = 0; j < 12; j++) { String line = (String) lines.get(j); for (int i = 0; i < width; i++) { if (i < line.length()) { char ch = line.charAt(i); Tile t = new Tile(i, j, Character.getNumericValue(ch)); tilearray.add(t); } } } } @Override public void update(float deltaTime) { List touchEvents = game.getInput().getTouchEvents(); // WHier haben wir 4 verschiedene update()-Methoden // Je nach Spielstand rufen wir eine der 3 auf. // Im dritten Kapitel haben wir schon �hnliches getan. if (state == GameState.Ready) updateReady(touchEvents); if (state == GameState.Running) updateRunning(touchEvents, deltaTime); if (state == GameState.Paused) updatePaused(touchEvents); if (state == GameState.GameOver) updateGameOver(touchEvents); } private void updateReady(List touchEvents) { // Wenn wir den Bildschirm ber�hren startet das Spiel if (touchEvents.size() > 0) state = GameState.Running; } private void updateRunning(List touchEvents, float deltaTime) { // Hier das ist Identisch mit Kapitel 2 und 3. // 1. Touch Eingaben werden hier verarbeitet: int len = touchEvents.size(); for (int i = 0; i < len; i++) { TouchEvent event = touchEvents.get(i); if (event.type == TouchEvent.TOUCH_DOWN) { if (inBounds(event, 0, 285, 65, 65)) { robot.jump(); currentSprite = anim.getImage(); robot.setDucked(false); } else if (inBounds(event, 0, 350, 65, 65)) { if (robot.isDucked() == false && robot.isJumped() == false && robot.isReadyToFire()) { robot.shoot(); } } else if (inBounds(event, 0, 415, 65, 65) && robot.isJumped() == false) { currentSprite = Assets.characterDown; robot.setDucked(true); robot.setSpeedX(0); } if (event.x > 400) { robot.moveRight(); robot.setMovingRight(true); } } if (event.type == TouchEvent.TOUCH_UP) { if (inBounds(event, 0, 415, 65, 65)) { currentSprite = anim.getImage(); robot.setDucked(false); } if (inBounds(event, 0, 0, 35, 35)) { pause(); } if (event.x > 400) { robot.stopRight(); } } } // 2. Hier wird �berpr�ft ob unser Roboter noch lebt. if (livesLeft == 0) { state = GameState.GameOver; } // 3. Hier werden alle update()-Methoden des Spiels gehandhabt. robot.update(); if (robot.isJumped()) { currentSprite = Assets.characterJump; } else if (robot.isJumped() == false && robot.isDucked() == false) { currentSprite = anim.getImage(); } ArrayList projectiles = robot.getProjectiles(); for (int i = 0; i < projectiles.size(); i++) { Projectile p = (Projectile) projectiles.get(i); if (p.isVisible() == true) { p.update(); } else { projectiles.remove(i); } } updateTiles(); hb.update(); hb2.update(); bg1.update(); bg2.update(); animate(); if (robot.getCenterY() > 500) { state = GameState.GameOver; } } private boolean inBounds(TouchEvent event, int x, int y, int width, int height) { if (event.x > x && event.x < x + width - 1 && event.y > y && event.y < y + height - 1) return true; else return false; } private void updatePaused(List touchEvents) { int len = touchEvents.size(); for (int i = 0; i < len; i++) { TouchEvent event = touchEvents.get(i); if (event.type == TouchEvent.TOUCH_UP) { if (inBounds(event, 0, 0, 800, 240)) { if (!inBounds(event, 0, 0, 35, 35)) { resume(); } } if (inBounds(event, 0, 240, 800, 240)) { nullify(); goToMenu(); } } } } private void updateGameOver(List touchEvents) { int len = touchEvents.size(); for (int i = 0; i < len; i++) { TouchEvent event = touchEvents.get(i); if (event.type == TouchEvent.TOUCH_DOWN) { if (inBounds(event, 0, 0, 800, 480)) { nullify(); game.setScreen(new MainMenuScreen(game)); return; } } } } private void updateTiles() { for (int i = 0; i < tilearray.size(); i++) { Tile t = (Tile) tilearray.get(i); t.update(); } } @Override public void paint(float deltaTime) { Graphics g = game.getGraphics(); g.drawImage(Assets.background, bg1.getBgX(), bg1.getBgY()); g.drawImage(Assets.background, bg2.getBgX(), bg2.getBgY()); paintTiles(g); ArrayList projectiles = robot.getProjectiles(); for (int i = 0; i < projectiles.size(); i++) { Projectile p = (Projectile) projectiles.get(i); g.drawRect(p.getX(), p.getY(), 10, 5, Color.YELLOW); } // Als erstes werden die Spielelemente gezeichnet. g.drawImage(currentSprite, robot.getCenterX() - 61, robot.getCenterY() - 63); g.drawImage(hanim.getImage(), hb.getCenterX() - 48, hb.getCenterY() - 48); g.drawImage(hanim.getImage(), hb2.getCenterX() - 48, hb2.getCenterY() - 48); // Beispiel: // g.drawImage(Assets.background, 0, 0); // g.drawImage(Assets.character, characterX, characterY); // Als zweites werden die UI Elemente gezeichnet. if (state == GameState.Ready) drawReadyUI(); if (state == GameState.Running) drawRunningUI(); if (state == GameState.Paused) drawPausedUI(); if (state == GameState.GameOver) drawGameOverUI(); } private void paintTiles(Graphics g) { for (int i = 0; i < tilearray.size(); i++) { Tile t = (Tile) tilearray.get(i); if (t.type != 0) { g.drawImage(t.getTileImage(), t.getTileX(), t.getTileY()); } } } public void animate() { anim.update(10); hanim.update(50); } private void nullify() { // Hier werden alle Variablen gleich null gesetzt, wir bearbeiten sie im Konstrukur paint = null; bg1 = null; bg2 = null; robot = null; hb = null; hb2 = null; currentSprite = null; character = null; character2 = null; character3 = null; heliboy = null; heliboy2 = null; heliboy3 = null; heliboy4 = null; heliboy5 = null; anim = null; hanim = null; // Speicheraufr�umen. System.gc(); } private void drawReadyUI() { Graphics g = game.getGraphics(); g.drawARGB(155, 0, 0, 0); g.drawString("Tap to Start.", 400, 240, paint); } private void drawRunningUI() { Graphics g = game.getGraphics(); g.drawImage(Assets.button, 0, 285, 0, 0, 65, 65); g.drawImage(Assets.button, 0, 350, 0, 65, 65, 65); g.drawImage(Assets.button, 0, 415, 0, 130, 65, 65); g.drawImage(Assets.button, 0, 0, 0, 195, 35, 35); } private void drawPausedUI() { Graphics g = game.getGraphics(); // Bildschirm wird abgedunkelt f�r Pause g.drawARGB(155, 0, 0, 0); g.drawString("Resume", 400, 165, paint2); g.drawString("Menu", 400, 360, paint2); } private void drawGameOverUI() { Graphics g = game.getGraphics(); g.drawRect(0, 0, 1281, 801, Color.BLACK); g.drawString("GAME OVER.", 400, 240, paint2); g.drawString("Tap to return.", 400, 290, paint); } @Override public void pause() { if (state == GameState.Running) state = GameState.Paused; } @Override public void resume() { if (state == GameState.Paused) state = GameState.Running; } @Override public void dispose() { } @Override public void backButton() { pause(); } private void goToMenu() { // TODO Auto-generated method stub game.setScreen(new MainMenuScreen(game)); } public static Background getBg1() { // TODO Auto-generated method stub return bg1; } public static Background getBg2() { // TODO Auto-generated method stub return bg2; } public static Robot getRobot() { // TODO Auto-generated method stub return robot; } } |
Der meiste Code sollte verständlich sein und auch bekannt. Wir erstellen verschiedene GameStates (Spielstände) die aufgerufen werden in der update() und paint()-Methode, daher müssen wir dafür nicht noch mehr Klassen erstellen und wir können auf die verschiedenen Spielstände eingehen.
Wir rufen nullify auf, hier setzen wir alles auf 0, jede Variable. Dadurch verhindern wir Duplikate und unser Speicher wird geschohnt.
Nun haben wir die 6 Basis Klassen erstellt und wir kopieren unsere 7 Spiele Klassen, mit ein paar Änderungen, in unser Spiel. Die größten Änderungen sind:
Image class – hier werden wir nicht die Bilder der Java Library nutzen, sondern die aus unser Image Klasse
Rectangle class – hier ersetzen wir die Java Rectangle mit der Android Rect Klasse.
Ansonsten wird sich nur wenig an unserem Code ändern. Hier sind nun unsere 7 Spiel Klassen:
1. Animation Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
package com.basteldroid.robotgame; import java.util.ArrayList; import com.basteldroid.framework.Image; public class Animation { private ArrayList frames; private int currentFrame; private long animTime; private long totalDuration; public Animation() { frames = new ArrayList(); totalDuration = 0; synchronized (this) { animTime = 0; currentFrame = 0; } } public synchronized void addFrame(Image image, long duration) { totalDuration += duration; frames.add(new AnimFrame(image, totalDuration)); } public synchronized void update(long elapsedTime) { if (frames.size() > 1) { animTime += elapsedTime; if (animTime >= totalDuration) { animTime = animTime % totalDuration; currentFrame = 0; } while (animTime > getFrame(currentFrame).endTime) { currentFrame++; } } } public synchronized Image getImage() { if (frames.size() == 0) { return null; } else { return getFrame(currentFrame).image; } } private AnimFrame getFrame(int i) { return (AnimFrame) frames.get(i); } private class AnimFrame { Image image; long endTime; public AnimFrame(Image image, long endTime) { this.image = image; this.endTime = endTime; } } } |
2. Background Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
package com.basteldroid.robotgame; public class Background { private int bgX, bgY, speedX; public Background(int x, int y){ bgX = x; bgY = y; speedX = 0; } public void update() { bgX += speedX; if (bgX <= -2160){ bgX += 4320; } } public int getBgX() { return bgX; } public int getBgY() { return bgY; } public int getSpeedX() { return speedX; } public void setBgX(int bgX) { this.bgX = bgX; } public void setBgY(int bgY) { this.bgY = bgY; } public void setSpeedX(int speedX) { this.speedX = speedX; } } |
3. Enemy Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
package com.basteldroid.robotgame; import android.graphics.Rect; public class Enemy { private int power, centerX, speedX, centerY; private Background bg = GameScreen.getBg1(); private Robot robot = GameScreen.getRobot(); public Rect r = new Rect(0, 0, 0, 0); public int health = 5; private int movementSpeed; // Behavioral Methods public void update() { follow(); centerX += speedX; speedX = bg.getSpeedX() * 5 + movementSpeed; r.set(centerX - 25, centerY - 25, centerX + 25, centerY + 35); if (Rect.intersects(r, Robot.yellowRed)) { checkCollision(); } } private void checkCollision() { if (Rect.intersects(r, Robot.rect)|| Rect.intersects(r, Robot.rect2) || Rect.intersects(r, Robot.rect3) || Rect.intersects(r, Robot.rect4)) { } } public void follow() { if (centerX < -95 || centerX > 810){ movementSpeed = 0; } else if (Math.abs(robot.getCenterX() - centerX) < 5) { movementSpeed = 0; } else { if (robot.getCenterX() >= centerX) { movementSpeed = 1; } else { movementSpeed = -1; } } } public void die() { } public void attack() { } public int getPower() { return power; } public int getSpeedX() { return speedX; } public int getCenterX() { return centerX; } public int getCenterY() { return centerY; } public Background getBg() { return bg; } public void setPower(int power) { this.power = power; } public void setSpeedX(int speedX) { this.speedX = speedX; } public void setCenterX(int centerX) { this.centerX = centerX; } public void setCenterY(int centerY) { this.centerY = centerY; } public void setBg(Background bg) { this.bg = bg; } } |
4. Heliboy Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package com.basteldroid.robotgame; public class Heliboy extends Enemy { public Heliboy(int centerX, int centerY) { setCenterX(centerX); setCenterY(centerY); } } |
5. Robot Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
package com.basteldroid.robotgame; import java.util.ArrayList; import android.graphics.Rect; public class Robot { final int JUMPSPEED = -15; final int MOVESPEED = 5; private int centerX = 100; private int centerY = 377; private boolean jumped = false; private boolean movingLeft = false; private boolean movingRight = false; private boolean ducked = false; private boolean readyToFire = true; private int speedX = 0; private int speedY = 0; public static Rect rect = new Rect(0, 0, 0, 0); public static Rect rect2 = new Rect(0, 0, 0, 0); public static Rect rect3 = new Rect(0, 0, 0, 0); public static Rect rect4 = new Rect(0, 0, 0, 0); public static Rect yellowRed = new Rect(0, 0, 0, 0); public static Rect footleft = new Rect(0,0,0,0); public static Rect footright = new Rect(0,0,0,0); private Background bg1 = GameScreen.getBg1(); private Background bg2 = GameScreen.getBg2(); private ArrayList projectiles = new ArrayList(); public void update() { if (speedX < 0) { centerX += speedX; } if (speedX == 0 || speedX < 0) { bg1.setSpeedX(0); bg2.setSpeedX(0); } if (centerX <= 200 && speedX > 0) { centerX += speedX; } if (speedX > 0 && centerX > 200) { bg1.setSpeedX(-MOVESPEED / 5); bg2.setSpeedX(-MOVESPEED / 5); } centerY += speedY; speedY += 1; if (speedY > 3){ jumped = true; } if (centerX + speedX <= 60) { centerX = 61; } rect.set(centerX - 34, centerY - 63, centerX + 34, centerY); rect2.set(rect.left, rect.top + 63, rect.left+68, rect.top + 128); rect3.set(rect.left - 26, rect.top+32, rect.left, rect.top+52); rect4.set(rect.left + 68, rect.top+32, rect.left+94, rect.top+52); yellowRed.set(centerX - 110, centerY - 110, centerX + 70, centerY + 70); footleft.set(centerX - 50, centerY + 20, centerX, centerY + 35); footright.set(centerX, centerY + 20, centerX+50, centerY+35); } public void moveRight() { if (ducked == false) { speedX = MOVESPEED; } } public void moveLeft() { if (ducked == false) { speedX = -MOVESPEED; } } public void stopRight() { setMovingRight(false); stop(); } public void stopLeft() { setMovingLeft(false); stop(); } private void stop() { if (isMovingRight() == false && isMovingLeft() == false) { speedX = 0; } if (isMovingRight() == false && isMovingLeft() == true) { moveLeft(); } if (isMovingRight() == true && isMovingLeft() == false) { moveRight(); } } public void jump() { if (jumped == false) { speedY = JUMPSPEED; jumped = true; } } public void shoot() { if (readyToFire) { Projectile p = new Projectile(centerX + 50, centerY - 25); projectiles.add(p); } } public int getCenterX() { return centerX; } public int getCenterY() { return centerY; } public boolean isJumped() { return jumped; } public int getSpeedX() { return speedX; } public int getSpeedY() { return speedY; } public void setCenterX(int centerX) { this.centerX = centerX; } public void setCenterY(int centerY) { this.centerY = centerY; } public void setJumped(boolean jumped) { this.jumped = jumped; } public void setSpeedX(int speedX) { this.speedX = speedX; } public void setSpeedY(int speedY) { this.speedY = speedY; } public boolean isDucked() { return ducked; } public void setDucked(boolean ducked) { this.ducked = ducked; } public boolean isMovingRight() { return movingRight; } public void setMovingRight(boolean movingRight) { this.movingRight = movingRight; } public boolean isMovingLeft() { return movingLeft; } public void setMovingLeft(boolean movingLeft) { this.movingLeft = movingLeft; } public ArrayList getProjectiles() { return projectiles; } public boolean isReadyToFire() { return readyToFire; } public void setReadyToFire(boolean readyToFire) { this.readyToFire = readyToFire; } } |
6. Projectile Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
package com.basteldroid.robotgame; import android.graphics.Rect; public class Projectile { private int x, y, speedX; private boolean visible; private Rect r; public Projectile(int startX, int startY){ x = startX; y = startY; speedX = 7; visible = true; r = new Rect(0, 0, 0, 0); } public void update(){ x += speedX; r.set(x, y, x+10, y+5); if (x > 800){ visible = false; r = null; } if (visible){ checkCollision(); } } private void checkCollision() { if (Rect.intersects(r, GameScreen.hb.r)){ visible = false; if (GameScreen.hb.health > 0) { GameScreen.hb.health -= 1; } if (GameScreen.hb.health == 0) { GameScreen.hb.setCenterX(-100); } } if (Rect.intersects(r, GameScreen.hb2.r)){ visible = false; if (GameScreen.hb2.health > 0) { GameScreen.hb2.health -= 1; } if (GameScreen.hb2.health == 0) { GameScreen.hb2.setCenterX(-100); } } } public int getX() { return x; } public int getY() { return y; } public int getSpeedX() { return speedX; } public boolean isVisible() { return visible; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void setSpeedX(int speedX) { this.speedX = speedX; } public void setVisible(boolean visible) { this.visible = visible; } } |
7. Tile Klasse
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
package com.basteldroid.robotgame; import android.graphics.Rect; import com.basteldroid.framework.Image; public class Tile { private int tileX, tileY, speedX; public int type; public Image tileImage; private Robot robot = GameScreen.getRobot(); private Background bg = GameScreen.getBg1(); private Rect r; public Tile(int x, int y, int typeInt) { tileX = x * 40; tileY = y * 40; type = typeInt; r = new Rect(); if (type == 5) { tileImage = Assets.tiledirt; } else if (type == 8) { tileImage = Assets.tilegrassTop; } else if (type == 4) { tileImage = Assets.tilegrassLeft; } else if (type == 6) { tileImage = Assets.tilegrassRight; } else if (type == 2) { tileImage = Assets.tilegrassBot; } else { type = 0; } } public void update() { speedX = bg.getSpeedX() * 5; tileX += speedX; r.set(tileX, tileY, tileX+40, tileY+40); if (Rect.intersects(r, Robot.yellowRed) && type != 0) { checkVerticalCollision(Robot.rect, Robot.rect2); checkSideCollision(Robot.rect3, Robot.rect4, Robot.footleft, Robot.footright); } } public int getTileX() { return tileX; } public void setTileX(int tileX) { this.tileX = tileX; } public int getTileY() { return tileY; } public void setTileY(int tileY) { this.tileY = tileY; } public Image getTileImage() { return tileImage; } public void setTileImage(Image tileImage) { this.tileImage = tileImage; } public void checkVerticalCollision(Rect rtop, Rect rbot) { if (Rect.intersects(rtop, r)) { } if (Rect.intersects(rbot, r) && type == 8) { robot.setJumped(false); robot.setSpeedY(0); robot.setCenterY(tileY - 63); } } public void checkSideCollision(Rect rleft, Rect rright, Rect leftfoot, Rect rightfoot) { if (type != 5 && type != 2 && type != 0){ if (Rect.intersects(rleft, r)) { robot.setCenterX(tileX + 102); robot.setSpeedX(0); }else if (Rect.intersects(leftfoot, r)) { robot.setCenterX(tileX + 85); robot.setSpeedX(0); } if (Rect.intersects(rright, r)) { robot.setCenterX(tileX - 62); robot.setSpeedX(0); } else if (Rect.intersects(rightfoot, r)) { robot.setCenterX(tileX - 45); robot.setSpeedX(0); } } } } |
Unser Spiel sollte nun wie folgt aussehen:
Nun müssen wir nur noch das AndroidManifest bearbeiten und unsere Berechtigungen einstellen.
AndroidManifest
Dieses Bild müsst ihr nun herunterladen und in den drawable-hdpi Ordner kopieren.
Wir werden nun 3 Berechtigungen einfordern, WakeLock, Externer Speicher und Vibration.
In dem Aktivity Teil, müssen alle Aktivitäten vermerkt werden, bei uns also nur die SampleGame.
Hier können wir den Namen unseres Spiels einstellen, die Tastatur verschwinden lassen und die Bildschirmausrichtung einstellen.
Mit dem intent Filter können wir die .SampleGame Aktivität als Hauptaktivität einstellen.
|
1 |
<a href="http://www.basteldroid.de/wp-content/uploads/2013/05/k4l7b8.png"><img class="alignnone size-full wp-image-1026" alt="k4l7b8" src="http://www.basteldroid.de/wp-content/uploads/2013/05/k4l7b8.png" width="1063" height="690" /></a> |
Wenn ihr nun das Spiel startet, könnt ihr euer erstes selbst programmiertes Spiel spielen.
Damit sind wir am Ende unserer Anleitung, aber keine Angst, damit sind wir noch lange nicht am Ende dieses Blocks. Wir werden in der nächsten Zeit noch einiges lernen. Wie veröffentlichen wir Spiele im Google Play Store, wie erstellen wir mehrere Level und und und.
Die nächste Anleitung wird sein, wie Programmieren wir unsere eigene App und wie halten wir diese immer auf dem neuesten Stand. Es steht also noch viel vor uns und ich hoffe das ihr weiter treu mit lernt.
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.
Quelle: Original Anleitung auf englisch von Kilobolt Studios
Lektion 6 – Grundgerüst eines Android Spiels Teil 2 Lektion 8 - Speichern und Laden von Spielständen