Hur man skapar grundläggande Android-spel med enhet

Krav:

• Enhet
• En bra textredigerare som NotePad ++ (valfritt men rekommenderas)
• Android SDK

Starta Unity och skapa ett nytt projekt. Gör det till ett 2D-projekt.

Det finns flera paneler att bekanta sig med - Hierarkipanelen som kommer att innehålla alla våra scenelement (scen = vilken 'nivå' du arbetar för närvarande). Sedan finns det fliken Spelet som används för att spela / testa ditt spel medan du är inne i redigeraren, och till höger har du inspektörspanelen där du kommer att redigera olika saker som belysning, fysik etc.

Det första vi vill göra är att skapa en sprite - det här blir vår huvudperson (som vi kontrollerar). Du kan antingen rita din egen sprite, som att bara rita en fyrkant med ögonen, eller så kan du ta en sprite från internet - se bara till att det är en .PNG-fil (transparent bakgrund).

Dra och släpp din sprite till huvudscenfönstret (det största fönstret) - det kommer också att visas i hierarkipanelen till vänster.

Så nu skapar vi några plattformar - det kan vara enkla rutor eftersom vi enkelt kan ändra storlek på dem för att skapa väggar och andra plattformar.

Så skapa bara en ny fyrkantig 'sprite' och dra och släpp den på scenfönstret som du gjorde med din sprite-karaktär.

Nu måste vi instruera Unity att ge fysik till vår huvudperson - klicka på din huvudsprite-karaktär (den ska markeras i blått i scenfönstret), leta sedan efter ”GameObjects” på inspektörspanelen.

Klicka på 'Lägg till komponent> Fysik 2D> RigidBody2D'. Detta kommer automatiskt att lägga till fysik på din sprite, som du annars skulle ha skriptat själv i en annan SDK.

Vi vill förhindra att huvudsprite-karaktären snurrar utom kontroll - så hitta fliken Begränsningar i inspektörspanelen (med huvudspriten fortfarande markerad i scenfönstret) och kryssa i rutan för 'Frysrotation Z'.

Om du trycker på 'Spela' -knappen ska din huvudsprite-karaktär falla från himlen och bara falla oändligt - det ska vi ta hand om senare, men notera bara hur vi enkelt kunde tillämpa fysik. Fysiken vi använde beror på formen de appliceras på - så om du till exempel använde samma fysik på en sfär skulle den rulla runt.

Vi vill också fixa vår orientering för att förhindra att karaktären snurrar och frihjular runt. Hitta 'begränsningar' i inspektören med vald spelare och kryssa i rutan för att frysa rotation Z. Klicka nu på play igen så ska du hitta att din spelare nu faller från himlen till sin oändliga undergång.

För att förhindra att vår huvudsakliga sprite-karaktär bara faller oändligt, måste vi lägga till en kolliderare. Detta är i grund och botten bara den solida konturen av en form som vi lägger till huvudspritkaraktären. Markera din huvudsprite-karaktär, klicka på “Lägg till komponent> Fysik 2D> BoxCollider2D.

Gör nu samma exakta sak med plattformen du skapade tidigare. Din huvudsakliga sprite-karaktär ska nu 'kollidera' med plattformen och stanna där.

Så nu vill vi se till att kameran följer din huvudsprite-karaktär - inne i scenen borde det redan finnas ett kameraobjekt. Du vill dra det här ovanpå huvudsprite karaktären.

Detta är särskilt viktigt om du skapar en 3D-baserad löpare , något liknande Backe där du behöver kameran för att stanna ständigt bakom det primära spelobjektet (din huvudsakliga sprite-karaktär).

Gå nu till hierarkipanelen och i listan över GameObjects vill du dra kameran undertill huvudspritkaraktären (Player GameObject). Detta gör huvudspritkaraktären till ” förälder' av kameran. Så när spelaren GameObject rör sig runt skärmen bör kameran följa.

Så för den här spelhandledningen ska vi bara skapa ett grundläggande oändligt spel av typ löpare, något liknande Kör 3 , där din huvudperson kommer att springa över skärmen och undvika hinder (eller 'game over' om du träffar ett hinder '. Detta kommer att ta några skript, varav de flesta kommer att ges i den här guiden.

Högerklicka på mappen 'Tillgångar' och skapa en ny mapp - namnge den Skript . Högerklicka nu på den här nya mappen och tryck på 'Skapa> C # -skript' och namnge den PlayerControls . Detta manus kommer att definiera beteendet hos vår huvudsprite-karaktär.

När du dubbelklickar på det här nya skriptet, det skall öppna i Visual Studio - alternativt (och min personliga preferens), kan du redigera den i något som NotePad ++.

Skriptsfilen ska redan ha lite 'pannplatta' -kod inuti - det här är i princip skript som måste lämnas ensamt eller bara anpassas till dina behov och sparar mycket tid. Så vi ska lägga till ett nytt objekt.

Ovanför linjen ogiltig Start ():

offentlig Rigidbody2D rb;

Nästa kodkod vi behöver lägga till kommer att gå inom Start () och används för att hitta den styva kroppen - i grund och botten instruerar vi Unity att lokalisera den fysik som vi kopplade till GameObjects (vår huvudsakliga sprite-karaktär) och Start () kommer att köras när ett nytt objekt eller skript skapas.

Så leta reda på fysikobjektet.

rb = GetComponent< Rigidbody2D > ();

Och du kommer att lägga till den här raden inuti uppdateringen ()

rb.velocity = ny Vector2 (3, rb.velocity.y);

Vad Update () gör uppdateras ständigt, så all kod som läggs till där körs kontinuerligt (såvida inte objektet förstörs). Så vad vi har gjort är att instruera skriptet att vi vill att den styva kroppen ska ha en ny vektor med samma hastighet på Y-axeln (rb.velocity.y), men med en hastighet på 3 på den horisontella axeln. I framtiden kan du också använda FixedUpdate () ’ vilket är liknande men annorlunda, för där kan du styra uppdaterings- / uppdateringsmängden för skriptet.

Spara skriptet och gå tillbaka till Unity och klicka sedan på din huvudsprite-karaktär för att markera det. Gå till panelen Inspektör, gå till Lägg till komponent> Skript och lägg till skriptet som vi just sparade. Nu när du klickar på Play-knappen ska huvudsprite-karaktären kontinuerligt röra sig mot plattformskanten.

Skapa spelarens ingångskontroller

Så eftersom det här är ett oändligt löparspel med hinder, måste vi lägga till kontroller för spelaren, till exempel en ”hoppknapp”.

Öppna skriptet från tidigare, så lägger vi till den här ytterligare koden:

 om (Input.GetMouseButtonDown (0)) {rb.velocity = ny Vector2 (rb.velocity.x, 5); }

Du kommer att lägga det in i Update () -metoden, och vad det i grund och botten gör är att berätta för Unity att när spelaren klickar på musknappen (som kommer att översättas som en skärmknapp på Android) kommer sprite-karaktären att 'hoppa ' i luften. Detta beror på att vi har lagt till en hastighet på Y-axeln med värdet 5 (ett högre värde skulle naturligtvis innebära ett högre hopp).

Om du inte är så bekant med kodning använde vi en Om uttalande för Om är i grunden en 'gör eller gör inte' typ av instruktion - det är bokstavligt talat Gör detta kommando om detta händer . Så om spelaren inte klickar på musen (eller knackar på deras Android-skärm) kommer skriptet självklart inte att köras.

Fortsätt och klicka på 'Spela' -knappen och se till att den fungerar korrekt innan du fortsätter.

Därefter ska vi lägga till våra hinder (som kan 'förstöra' huvudpersonen sprite), ett spelresultat och en 'game over' -meny.

Om du testat spelet hittills är det enda problemet vi har hittills att trycka på 'hoppa' -knappen vi skapade kommer att hoppa karaktären oavsett om de är jordade eller inte - det här är i princip Flappy Birds, och inte en löpare som Vi vill. Men vi ska fixa det.

Lägg till den här biten kod i skriptet ovan metoden Update ():

 offentlig Omvandla groundCheck; offentlig Omvandla startPosition; offentlig   flyta groundCheckRadius; offentlig LayerMask whatIsGround; privat   bool på marken; Och lägg sedan till nästa rad i uppdateringsmetoden ovanför om uttalande: onGround = Physics2D.OverlapCircle (groundCheck.position, groundCheckRadius, whatIsGround); Och nästa kommer du att ändra följande rad för att inkludera '&& onGround' om (Input.GetMouseButtonDown (0) && onGround) {Så hela skriptet ska i princip se ut så här: offentlig   klass   PlayerControls : MonoBehaviour { offentlig Rigidbody2D rb; offentlig Omvandla groundCheck; offentlig Omvandla startPosition; offentlig   flyta groundCheckRadius; offentlig LayerMask whatIsGround; privat   bool på marken; tomhet   Start () {rb = GetComponent (); } tomhet   Uppdatering () {rb.velocity = ny Vector2 (3, rb.velocity.y); onGround = Physics2D.OverlapCircle (groundCheck.position, groundCheckRadius, whatIsGround); om (Input.GetMouseButtonDown (0) && onGround) {rb.velocity = ny Vector2 (rb.velocity.x, 5); }}}

För att förklara vad vi har gjort har vi skapat en ny ”transform”, vilket betyder en position i spelvärldens utrymme. Vi har ställt in sin radie och vi instruerar Unity att kontrollera om radien överlappar vårt 'mark' -lager - och om vår radie synkroniseras med 'marken' bör vår karaktär kunna hoppa, och om vi är redan i luften från ett hopp, vi borde inte kunna hoppa igen. I grund och botten, på marken kommer att vara sant om den transform som heter markCheck överlappar med jordskiktet. Förhoppningsvis är det vettigt.

Så spara manuset och gå tillbaka till Unity så märker du att fler alternativ har lagts till inspektören efter att du har markerat spelaren. Dessa är offentliga variabler och vi kan anpassa dem efter eget tycke.

Högerklicka nu på hierarkin och skapa ett nytt tomt objekt och dra det så att det är under huvudpersonen sprite i huvudfönstret - placera det tomma objektet där vi vill att golvet ska upptäckas. Byt namn på objektet till 'Kontrollera marken' och dra det under spelarens spelobjekt som vi gjorde tidigare med kameran (för att skapa en förälder-barn-relation mellan objekten). Nu kommer det tomma objektet att följa huvudpersonen sprite, precis som kameran, och den kommer kontinuerligt att kontrollera golvavståndet. Kamera

Välj nu huvudpersonen sprite och gå till inspektörspanelen - dra objektet Check Ground till det utrymme som kallas ”groundCheck”. 'Transform' -positionen ska vara lika med positionen för detta nya objekt, och där det står 'Radius', gör det till 0,1.

Vi måste definiera marklagret. Välj bara markterrängen och i inspektören, hitta knappen för 'Layer: Standard' (det är en rullgardinsruta) och välj 'Add Layer'.

Välj nu ”mark” som lager för vår plattform och upprepa detta för alla andra plattformar i spelfönstret. Där det står 'Vad är mark' på vårt huvudkaraktär sprite-objekt, välj också marklagret.

Vad vi har gjort är att instruera spelarskriptet att utföra en kontroll - om den lilla punkten på skärmen överlappar var som helst som matchar lagret, karaktären hoppar bara om detta är sant.

Game Over på kollision och spelmeny

Så för att avsluta allt är de sista sakerna vi vill göra A: Gör att kollidera med hinder resulterar i ett spel över, och B: Skapa en 'game over' -menyskärm med en uppspelningsknapp.

Vad du i princip vill göra är:

1. Lägg till en Spelare invända och tilldela en styv kropp och a kollider av ditt val till det.
2. Lägg till en Fiende invända och tilldela en styv kropp och a kollider av ditt val till det. (och valfritt, lägg till Tag 'Enemy' till det)
3. Skapa en ny C # -skript och lägg till den som en komponent i Spelare (eller använd något skript bifogat spelaren, du behöver inte skapa ett nytt om du redan har ett)
4. Lägg till detta i ditt skript:

tomhet OnCollisionEnter ( Kollision koll) { Felsöka . Logga ('Kollision'); // Kontrollera om det ens registrerar en kollision. Om det fungerar kan du ta bort den här raden if (koll. spelobjekt. märka == 'Fiende') { // ser om objektet som din spelare kolliderade med har en tagg som heter 'Enemy'