ABC'erne til Android-spiludvikling: Forbered lærredet

I Google Play er 23 af de 25 største applikationer til Android-telefoner og tablets spil (på dette tidspunkt). Så det giver kun mening, at hvis du er i eller overvejer at komme ind i det mobile rum, som du måske overvejer at prøve dig på at skrive underholdningssoftware.

Selv for en erfaren softwareingeniør kan kodning af et spil være lidt skræmmende. Det er ikke, at det er sværere at skrive spil end at udvikle andre typer applikationer, det er bare anderledes. Spilprogrammering har sine egne teknikker, paradigmer og ordforråd - du hører spiludviklere tale om sprites, frame-rate, verdens-koordinater og pixel-perfekt kollisionsdetektion.

Sidste år, da jeg sammen med min søn skrev mit første spil, fandt jeg mig selv i at kæmpe Internettet og fora for enkle tutorials, der dækkede det grundlæggende. Der er en overvældende mængde information derude, men spilprogrammering er ofte specifik for en platform og / eller værktøj. Jeg besluttede at skrive en serie til TechRepublic-læsere, der introducerer de vigtigste koncepter for kodning af spil på Android-platformen og resulterer i et næsten komplet spil, der demonstrerer de diskuterede teknikker.

Dette er det første indlæg i denne femdelt serie. Kildekoden i hver rate bygger på den fra det foregående indlæg. Du vil kunne følge med hver tutorial eller downloade projektet og importere det direkte til Eclipse. Som med at lære noget nyt, skal vi gå, før vi kan flyve. Selvom koden i slutningen af ​​del 1 af denne tutorial udføres, vil den derfor ikke være meget underholdende. Frygt aldrig, det kommer derhen. I mellemtiden er nedenunder et kig på det færdige spil.

Figur A

Dette er et skærmbillede af vores færdige spil. Målet er at justere skålens momentum for at undgå at blive smadret til biter af asteroiden. Mens det er forenklet, indeholder projektet alle de væsentlige aspekter af et videospil: et lærred, sprites, animation, kollisionsdetektion og brugerinput.

Hvis du ikke har udført nogen Android-programmering, er det også okay. Der er masser af værktøjer til rådighed til at skrive mobilspil, og i et senere indlæg vil jeg diskutere nogle af alternativerne. Mine hovedårsager til at vælge Android's lærred og standard SDK er to gange. For det første er teknikkerne ikke så komplicerede at skræmme en begynder væk. (Mens OPENGL er mere performant, er det ofte nok at få noget til at vises på skærmen til at knuse en spirende spiludviklers sjæl.) For det andet er alle værktøjer gratis og kan downloades og konfigureres under Mac OS, Linux og Microsoft Windows. Jeg er en stor fan af Corona SDK og Unity, men begge koster penge for at komme i gang og kun køre under visse operativsystemer.

Hvis dette er din første gang, du læser TechRepublic's Android App Builder-blog, har vi en newbies-guide til Android-udvikling. Du ønsker også at se på Googles officielle dokumentation til installation og opsætning af dit udviklingsmiljø.

Klargøring af lærredet

1. Opret et nyt Android-projekt i Eclipse. Fordi vi senere bruger nogle af gestusdetektorindgange, der ikke var en del af 1.0 SDK, vil vi sikre os, at minimumversionen af ​​målrettet Android er 2.1 (Eclair) eller bedre. Husk at omdøbe din startaktivitet til Main.java og det tilsvarende layout til main.xml.

2. Rediger filen AndroidManifest.XML. Især vil vi tilføje en egenskab til vores aktivitet, der får enheden til at ignorere retningsændringer og altid tvinge skærmen til portrættilstand.

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 = "@ streng / app_navn" 
 android: theme = "@ style / AppTheme" > 
 android: screenOrientation = "portræt" android: configChanges = "orientering | tastatur skjult " 
 android: name = ".Main" 
 android: label = "@ string / title_activity_main" > 
 "android.intent.action.MAIN" /> 
 "android.intent.category.LAUNCHER" /> 

3. Definer layout til vores applikation. Find main.xml i mappen / res / layout. For det meste, hvis du har udført nogen Android-programmering, skal du genkende layoutkomponenterne. Jeg oprettede et standardlinjet layout ved hjælp af almindelige Android UI-widgets med én undtagelse. Bemærk, at det allerførste element i layoutet er defineret som et GameBoard; dette er vores egen brugerdefinerede visning og hjertet i at tegne vores spil på skærmen. For nu skal du sikre dig, at hvis du ikke brugte det samme pakkenavn, som jeg gjorde (com.authorwjf.drawing), at du peger det på din pakke.

main.xml

 "Http://schemas.android.com/apk/res/android" 
 android: layout_width = "fill_parent" 
 android: layout_height = "fill_parent" 
 android: orientering = "lodret" > 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "top | center" 
 android: text = "ABC'er fra Android Game Dev" /> 
 android: id = "@ + id / the_button" 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 android: tyngdekraft = "center" 
 android: aktiveret = "falsk" 
 android: text = "Nulstil" /> 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 android: text = "Sprite Speed ​​(?, ?)" 
 android: id = "@ + id / the_label" /> 
 android: layout_width = "wrap_content" 
 android: layout_height = "wrap_content" 
 android: layout_gravity = "center" 
 android: text = "Sidste 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. Gå til vores / src-bibliotek, og opret en ny .trækningspakke. I mit tilfælde er pakken com.authorwjf.drawing. Tilføj en ny klassefil i denne pakke og kald den GameBoard.java; denne nye klassefil vil håndtere al tegning til vores lærred. I sin første inkarnation maler GameBoard.java simpelthen en sort baggrund og udfylder et stjernefelt med tilfældige pulserende stjerner.

GameBoard.java

 pakke com.authorwjf.drawing; 
 import java.util.ArrayList; 
 import java.util.List; 
 import java.util.Random; 
 import android.content.Context; 
 import android.graphics.Canvas; 
 import android.graphics.Color; 
 import android.graphics.Paint; 
 import android.graphics.Point; 
 import android.util.AttributeSet; 
 import android.view.View; 
 offentlig klasse GameBoard udvider Vis { 
 privat maling; 
 privat liste starField = null ; 
 privat int starAlpha = 80; 
 privat int starFade = 2; 
 privat statisk endelig int NUM_OF_STARS = 25; 
 synkroniseret offentligt tomrom resetStarField () { 
 starField = null ; 
 } 
 public GameBoard (Kontekstkontekst, AttributeSet aSet) { 
 super (kontekst, aSet); 
 // Det er bedst ikke at oprette nye objekter i lodtrækningen 
 // initialiser dem som klassevariabler her 
 p = ny maling (); 
 } 
 private void initializeStars ( int maxX, int maxY) { 
 starField = ny ArrayList (); 
 for ( int i = 0; i < NUM_OF_STARS ; i ++) { 
 Tilfældig r = ny Tilfældig (); 
 int x = r.nextInt (maxX-5 + 1) +5; 
 int y = r.nextInt (maxY-5 + 1) +5; 
 starField.add ( nyt punkt (x, y)); 
 } 
 } 
 @Override 
 synkroniseret offentligt tomrum onDraw (lærred lærred) { 
 // Opret et sort lærred 
 p.setColor (farve. SORT ); 
 p.setAlpha (255); 
 p.setStrokeWidth (1); 
 canvas.drawRect (0, 0, getWidth (), getHeight (), p); 
 // initialiser starfield om nødvendigt 
 if (starField == null ) { 
 initialisereStars (canvas.getWidth (), canvas.getHeight ()); 
 } 
 // tegne stjernerne 
 p.setColor (farve. CYAN ); 
 p.setAlpha (starAlpha + = starFade); 
 // falme dem ind og ud 
 if (starAlpha> = 252 || starAlpha <= 80) starFade = starFade * -1; 
 p.setStrokeWidth (5); 
 for ( int i = 0; i < NUM_OF_STARS ; i ++) { 
 canvas.drawPoint (starField.get (i) .x, starField.get (i) .y, p); 
 } 
 } 
 } 

5. Rediger filen /src/Main.java. Hovedklassefilen er opladet til at opdatere koordinaterne for alle brugerobjekter, der vil blive trukket til skærmen af ​​GameBoard-klassen, håndtere brugerinput og billedhastigheden. Ved periodisk at placere en ugyldiggørelse på lærredet, tvinger Main.java lærredet til at tegne om indholdet for at afspejle eventuelle opdateringer i handlingen. Tænk på Main.java som hjernen bag vores spil.

Main.java

 pakke com.authorwjf.gamedevtut; 
 import com.authorwjf.drawing.GameBoard; 
 import com.authorwjf.gamedevtut.R; 
 import android.os.Bundle; 
 import android.os.Handler; 
 import android.app.Aktivitet; 
 import android.view.View; 
 import android.view.View.OnClickListener; 
 import android.widget.Button; 
 public class Main udvider Aktivitetsimplementeringer OnClickListener { 
 privat håndtereramme = ny håndterer (); 
 // Del rammen med 1000 for at beregne, hvor mange gange i sekundet skærmen opdateres. 
 privat statisk endelig int FRAME_RATE = 20; // 50 billeder i sekundet 
 @Override 
 offentligt tomrum onCreate (Bundle gemtInstanceState) { 
 super .onCreate (gemtInstanceState); 
 setContentView (R.layout. main ); 
 Håndterer h = ny Håndterer (); 
 ((Knap) findViewById (R.id. The_button )). SetOnClickListener ( dette ); 
 // Vi kan ikke initialisere grafikken med det samme, fordi layoutadministratoren 
 // skal køre først, så vi ringer tilbage om et sekund. 
 h.postDelayed ( nyt Runnable () { 
 @Override 
 offentlig annullering () { 
 initGfx (); 
 } 
 }, 1000); 
 } 
 synkroniseret offentligt tomrum initGfx () { 
 ((GameBoard) findViewById (R.id. The_canvas )). ResetStarField (); 
 ((Knap) findViewById (R.id. The_button )). SetEnabled ( sand ); 
 // Det er en god ide at fjerne eventuelle eksisterende tilbagekald, der skal opbevares 
 // dem fra uforvarende stabling. 
 frame.removeCallbacks (frameUpdate); 
 frame.postDelayed (frameUpdate, FRAME_RATE ); 
 } 
 @Override 
 synkroniseret offentligt tomrum onClick (Vis v) { 
 initGfx (); 
 } 
 private Runnable frameUpdate = new Runnable () { 
 @Override 
 synkroniseret offentligt tomrumsløb () { 
 frame.removeCallbacks (frameUpdate); 
 // foretage eventuelle opdateringer til skærmobjekter her 
 // påkald derefter on-draw ved at ugyldige lærredet 
 ((GameBoard) findViewById (R.id. The_canvas )). Ugyldig (); 
 frame.postDelayed (frameUpdate, FRAME_RATE ); 
 } 
 }; 
 } 

Projektet skal være klar til at kompilere og indlæse på din enhed eller emulator. Det vil trække vores stjernefelt og pulse stjernerne ind og ud. Ved at trykke på nulstillingsknappen får appen til at vælge nye tilfældige koordinater for stjernerne. Hvis du ikke har meget erfaring med Android-udvikling, er simulatoren smerteligt langsom, så du skal ikke bekymre dig, hvis den animerede effekt af stjernerne ikke er så snappy, som du gerne vil. Kør den på en faktisk telefon, og jeg tror, ​​du vil være tilfreds med resultaterne.

Kom tilbage til bloggen til Android App Builder for del to i denne serie, der vil fokusere på sprites.

© Copyright 2021 | pepebotifarra.com