Ladda ner unity 3d-appen för Android. Använder Unity för att utveckla applikationer. Hur man skapar spel i Unity
Att utveckla spel för Android OS-enheter kräver ett tillvägagångssätt som liknar utveckling för iOS. Å andra sidan är hårdvaran på Android-enheter inte föremål för tydliga standarder, vilket gör det nödvändigt att lösa problem som saknas när man arbetar med iOS. Det finns också skillnader mellan Android- och iOS-versionerna av Unity.
Förbereder Android-utvecklingsmiljön
Innan du kan testa dina spel på enheten måste du förbereda din utvecklingsmiljö. I synnerhet ladda ner och installera Android SDK för den önskade plattformen och lägg till din enhet i systemet (denna process är annorlunda för Windows och Mac). Detta är skrivet i detalj på Android-utvecklarens webbplats, och ytterligare information kan tillhandahållas av tillverkaren av din enhet. Eftersom detta är en ganska komplicerad process har vi förberett en liten instruktion som hjälper dig att förbereda allt du behöver för utveckling. Om du behöver mer information kan du få den från Android Developer Portal.
Tillgång till Android-funktioner
Unity tillhandahåller ett API för åtkomst till Android-ingång och inställningar. De tillgängliga klasserna finns dokumenterade på sidan Code for Android Assemblies.
Länka C, C++ eller Java-kod till skript
Unity låter dig anropa funktioner skrivna i C/C++ direkt från skript (Java-funktioner kan anropas indirekt). För att lära dig hur du får åtkomst till funktioner från inbyggd kod från Unity, besök Android-plugin-byggsidan.
Occlusion Culling (klippning av osynlig geometri)
Unity ger stöd för ocklusionsavlivning, vilket är mycket användbart vid optimering för mobila plattformar. Mer information finns på sidan för ocklusionsavlivning.
Anpassa startskärmen
Startskärmen som visas när spelet startar kan anpassas - se den här sidan för mer information.
Felsökning och felrapportering
Det finns många anledningar till att din app kraschar eller inte fungerar korrekt. Vår guide för att lösa Android-specifika problem hjälper dig att hantera orsakerna till fel på kortast möjliga tid. Om du efter att ha läst manualen antar att problemet ligger i Unity bör du lämna in en felrapport. Se den här sidan för instruktioner.
Hur Unity för Android skiljer sig från skrivbordsversionen
JavaScript med stark skrivning
För att förbättra prestandan i Android-versionen av Unity är dynamisk skrivning i JavaScript alltid inaktiverad (som om #pragma strict automatiskt tillämpades på varje skript). Detta är viktigt att komma ihåg om du porterar ett projekt till Android från äldre plattformar, och om du stöter på kompileringsfel, bör problemet först och främst letas efter när du skriver. Sådana fel är vanligtvis lätta att hantera genom att se till att typerna av alla variabler är explicit specificerade eller castade under initieringen.
Medan Unity Android stöder DXT/PVRTC/ATC-texturer, kommer Unity att dekomprimera texturer till RGB(A)-format under körning om dessa komprimeringsmetoder inte stöds på den specifika enheten. Detta kan allvarligt påverka GPU-renderingsprestandan, så det rekommenderas att använda ETC-formatet. Det är de facto-standarden för Android och bör stödjas av alla moderna enheter. Å andra sidan stöder ETC inte en alfakanal, och ibland är 16-bitars RGBA-texturer det bästa valet vad gäller kvalitet, storlek och renderingshastighet där en alfakanal behövs.
Visningar av inlägg: 19 374
Vi pratade om hur du kan skapa ditt eget spel på Android med Unreal Engine. I den här artikeln kommer vi att titta på en annan lika populär spelutvecklingsmotor - enhet.
Unity är en mycket känd motor bland indieutvecklare. Faktum är att det är en plattformsoberoende motor som låter dig utvecklas 3D- och 2D-spel. Funktionen som skiljer Unity från andra motorer är den låga starttröskeln för nybörjare, samtidigt som den har en rik verktygslåda för proffs. Cross-platform låter dig utveckla applikationer för alla plattformar, från stationära spel till mobila.
Separat är det värt att nämna prenumerationssystemet, eftersom Unity inte är en helt gratis produkt. Det finns flera typer av prenumerationer:
- Personlig. Gratisversion som innehåller alla huvudfunktioner i motorn. Den har följande begränsning: inkomst per år eller mängden insamlade medel får inte överstiga 100000$ .
- Plus. Per $35 per månad olika rapporter och analyser tillhandahålls, såväl som möjligheten att ändra startskärmen, 20% -th rabatt på köp i Asset Store och olika mindre förmåner. Den har följande begränsning: årets inkomst eller beloppet av insamlade medel får inte överstiga 200000$ .
- Proffs. Per $125 per månad innehåller alla fördelar med versionen Plus och dessutom professionell service och premiumsupport. Inga begränsningar för omsättning eller mängd medel.
- Separata versioner för företag (används av stora företag).
Indieutvecklare med små budgetar borde alltså vara nöjda med versionen Personlig eller Plus annars måste du prenumerera Proffs. I den här artikeln kommer vi att använda gratis version för första åket.
Steg 1 Installera Unity
För att börja installera Unity måste du gå till Unity Store-webbplatsen, där du blir ombedd att välja typ av prenumeration. Som nämnts ovan väljer vi Personlig.
Du kommer då att bli ombedd att acceptera användarvillkoren och ladda ner installationsprogrammet. Du kan också checka ut Systemkrav att arbeta med Unity.
Efter att ha startat installationsprogrammet kommer du att uppmanas att välja vilka komponenter som ska installeras. Eftersom vi behöver skapa en Android-applikation kommer vi att markera rutan för Android Build Support. Dessutom, om så önskas, istället för med Unity, kan du installera Visual Studio Community 2017 för programmering på C#.
Efter det återstår bara att välja installationsväg och börja installera Unity.
Steg 2: Registrera och konfigurera Unity
Efter att ha slutfört installationen och kört Unity uppmanas vi att logga in med vårt konto.
Då kommer du återigen att bli ombedd att välja ett abonnemang, vi kommer också att fokusera på Personligt. I det här fallet måste du bekräfta att företagets årsinkomst är mindre än 100 000 USD, eller att Unity används i utbildningssyfte.
I slutet föreslås det att du gör en liten enkät där du behöver svara på vad du gör och i vilket syfte du installerar Unity.
Steg 3. Skapa ett nytt projekt
Efter att ha konfigurerat Unity kommer vi till skärmen för att välja / skapa ett projekt. Klicka här Ny att skapa din nytt projekt.
Efter det, i fönstret som visas, uppmanas du att ange namnet på projektet och katalogen där det kommer att finnas. Glöm inte heller att bocka i rutan 3D för att använda redigeraren i 3D-läge.
När du är klar med detta, klicka Skapa projekt att skapa ett projekt. Därefter öppnas ett redigeringsfönster med en förgenererad scen.
Vi kommer ännu inte att ta itu med programmeringens krångligheter och ta till exempel avslutat spel. För detta finns Asset Store, som innehåller ett stort antal färdiga modeller, animationer, ljud (och till och med spel), både betalda och gratis.
För att öppna Asset Store behöver du i menyn Fönster välja Asset Store(tangentkombination ctrl-9).
Butiksfönstret öppnas. Skriv in i sökfältet " flappy bird stil exempel spel" och öppna ett gratis exempel som vi kommer att använda i vårt projekt.
Klickar Ladda ner och efter att ha laddat ner det kan du sedan importera det till ditt projekt. För att göra detta, klicka Importera, varefter en varning kommer att visas om att projektinställningarna kommer att ändras efter import.
Efter att ha godkänt importen kommer du att se ett fönster där du måste välja vilka komponenter som ska importeras. Markera alla och klicka Importera.
När importen är klar kommer du att se de nya filerna i projektbläddraren. Det här är spelfilerna. För att öppna scenen i redigeraren, expandera Flappy Bird Style - scener och dubbelklicka på Main.
Som ett resultat kommer spelscenen att visas i 3D-redigeringsfönstret.
Du kan kontrollera hur spelet fungerar direkt i Unity genom att klicka på knappen spela ovanför redigeringsfönstret.
Steg 4 Konfigurera Android-verktyg
Notera: om du använder android studio, då har du redan allt installerat nödvändiga komponenter och så kan du säkert gå vidare till nästa steg.
För att montera det resulterande spelet på Android måste du installera följande verktyg:
- Java Development Kit (JDK). Du kan ladda ner den från Java-webbplatsen. Genom att klicka på länken ser du högst upp Java Platform (JDK), Klicka på Ladda ner bredvid inskriptionen, välj sedan ditt operativsystem och börja ladda ner. Därefter följer du bara instruktionerna från installatören.
- Android SDK. av de flesta på ett enkelt sätt för att installera den senaste versionen är att ladda ner Android Studio som denna SDK kommer med. För att göra detta, gå till Android Studios webbplats och klicka Ladda ner Android Studio. Android Studio-installationsprogrammet installerar de grundläggande Android SDK-komponenterna som krävs för Android-utveckling.
Steg 5. Förbered projektet för lansering
Först måste du ändra utvecklingsplattformen till Android. För att göra detta, i Unity, öppna Arkiv-menyn och välj Bygginställningar.
Välj i fönstret som visas Android och tryck sedan på byta plattform.
Plattformsväxeln talar om för oss att vi kommer att bygga en Android-app. Det betyder att när vi bygger applikationen kommer Unity att skapa APK-fil. Plattformsväxeln tvingar också Unity att återimportera alla tillgångar i projektet. Detta kommer inte att ta lång tid på ett litet projekt, men tänk på att denna operation kan ta lång tid på stora projekt.
Nu måste vi ange ett paketnamn för applikationen.
Notera: Paketnamnet är en unik identifierare för applikationen och skrivs i omvänd DNS-stil i formatet com.CompanyName.ProductName. När appen har publicerats på Google Play kan paketnamnet inte längre ändras.
För att göra detta, gå till menyn Redigera och välj Projektinställningar - Spelare.
På höger sida av Unity öppnas ett fönster med många olika inställningar, såsom applikationsversion, mål- och minimi-SDK, ikonval, etc. Här behöver vi i blocket Andra inställningar hitta Identifiering och ange paketnamnet i fältet Paketnamn. Du kan även ändra andra inställningar om du vill.
Nu återstår bara att ange sökvägen till Android SDK och JDK. För att göra detta, gå till menyn och välj Redigera inställningar.
I fönstret som visas, gå till Externa verktyg och på fälten SDK och JDK ange lämpliga sökvägar och stäng sedan fönstret.
Steg 6: Bygga och köra applikationen
Det är dags att bygga din första Unity-app. För att göra detta, välj från menyn Arkiv - Bygginställningar. Ett fönster öppnas där du måste lägga till scenen som du vill sätta ihop. Eftersom vi redan har den här scenen öppen i editorn, klicka bara Lägg till öppna scener för att lägga till den i sammansättningen, efter att ha lagt till den kommer du att se den i listan över scener.
Det återstår bara att trycka Bygga, varefter Unity börjar bygga applikationen. Innan dess kan du bli ombedd att välja en mapp där de insamlade programfilerna ska sparas, samt namnet på APK-filen.
Notera: för tillfället, om du har alfaversionen installerad i Android SDK Byggverktyg(version 28.0.0-rc1), när man bygger Gradle kommer att ge ett fel. För att fixa detta, ta helt enkelt bort den här versionen från Android SDK.
Som ett resultat kommer den byggda APK-filen att visas i mappen du angav, redo att installeras på emulatorn eller på en riktig enhet.
Låt oss se vad som finns i den byggda APK-filen. För att göra detta använder vi verktyget APK-analysator, som ingår i Android Studio,
Den okomprimerade APK-filstorleken är 21,1 MB, i en komprimerad 20,9 MB. Som du kan se från grafen är det mesta av volymen upptagen av tredjepartsbibliotek som lagts till av Unity. Sedan i tillgångar alla resurser som används i den sammansatta scenen finns. Fil classes.dex innehåller endast 89 klasser och 479 metoder.
Dessutom, om man tittar på AndroidManifest.xml, applikationen består av en aktivitet.
Slutsats
Det är allt. I den här artikeln lärde vi oss hur man installerar och konfigurerar Unity och byggde också vår första Android-app.
Unity är den motor på vilken de flesta av moderna spel på olika plattformar. Genom motorn är det verkligen möjligt att skapa spel som är orienterade för att köras på datorer (Windows, Linux, MacOS), mobiltelefoner, surfplattor (Android, iOS) och till och med spel konsoler PlayStation, Xbox, Nintendo.
Hur skapar man spel i Unity?
Unity bygger på ett komponentorienterat koncept. Faktum är att vilket spel som helst består av en massa föremål utspädda med ytterligare komponenter. Till exempel, under skapandet av ett plattformsspel skapar vi ett GameObject, bifogar dessutom en grafisk komponent till den, som är ansvarig för att visa karaktären, och en kontrollkomponent, den ger kontroll över karaktären med hjälp av en mus, tangentbord, joystick eller pekskärm. Motorn sätter inga begränsningar på antalet sådana moduler. Vi kan lägga till så många komponenter till GameObject som behövs. Allt arbete med motorn är baserat på själva skapandet av GameObject och appliceringen av lämpliga komponenter på dem.
Nybörjare kan bli vilseledda av den uppenbara enkelheten i processen, även om så inte är fallet. För att skapa ett unikt och populärt spel måste du skriva många komponenter från grunden. Mer specifikt, i Unity-miljön kallas detta ett script. Det ursprungliga skriptspråket är C#, men JavaScript och Boo (en beskuren version av Python) används också delvis. Att skapa sina egna komponenter är inte lätt, man kan till och med säga att det är en komplex procedur, direkt kopplad till klassisk programmering. Utan en tillräcklig kunskapsnivå i programmering blir det svårt.
Plattformar som stöds
Många stora projekt föredrar Unity på grund av den enorma listan över plattformar som är kompatibla med motorn. Den färdiga applikationen kan startas på alla datoroperativsystem, populära mobilplattformar och SmartTV. Vad kan vi säga, även webbläsarspel och applikationer för specifika plattformar ( som Tizen OS) är övervägande utvecklade i Unity.
Men allt är inte så smidigt här. Vid behov kan du skriva specifika algoritmer baserade på lågnivåkod, för samma Android behöver du ha en grundlig kunskap om Java.
Detsamma gäller för iOS. En annan funktion hos iOS är att det går att utveckla för det endast från en dator eller surfplatta från Apple. I avsaknad av en Macbook eller liknande enhet kommer lanseringen av spelet snabbt att stanna och Unity har inget med det att göra, Apple inför en liknande begränsning. Slutsatsen är enkel: om det finns en iOS-utveckling i planerna bör du välja en lämplig enhet för montering i förväg.
Hur och var utvecklar man ett spel på motorn?
Vi kan genomföra en lång process av spelutveckling både inom Windows och Mac OS X. Det finns redan versioner av editorn för Linux, men än så länge kan vi inte räkna med att de fungerar stabilt. En utvecklare tillbringar det mesta av tiden med att skapa ett spel i Unity-redigeraren. Vi har fortfarande mycket tid på oss att skriva skriptkod, vi kan skapa den antingen i standard MonoDevelop eller i valfri tredjepartsredigerare. Nu använder de aktivt Visual Studio, såväl som Sublime Text, men bara med rätt konfiguration.
Utveckling mobilapplikationerär en av de mest lönsamma yrkena inom datorbranschen. Att skapa ett Android-spel kostar hundratals eller tusentals dollar, och vinsten kan nå upp till en miljon dollar. I detta avseende är många människor intresserade av att utveckla applikationer för telefonen. I den här artikeln kommer du att lära dig hur du skapar ett Android-spel från grunden med hjälp av en dator, vilken motor och designer är bättre att välja.
Ingen framgångsrikt spel kan inte göra utan vacker grafik, så skapandet av design är ett av de viktigaste utvecklingsstadierna. Design på Android OS implementeras med hjälp av ett "designdokument" eller designdokument. Du måste börja skapa en leksak med dess detaljerade studie. Filen innehåller:
- Objektmodeller;
- Funktionella specifikationer;
- Spelinnehåll;
- Gränssnitt.
Låt oss överväga var och en av punkterna mer i detalj.
Objektmodeller
Detta är information om funktionaliteten för varje objekt. Objektmodeller är ansvariga för möjligheten att köpa och sälja föremål, samt för att förbättra karaktärernas spelegenskaper.
Funktionella specifikationer
Den beskriver spelet, huvuddragen hos varje karaktär. Den beskriver också funktionerna spelobjekt- vapen, första hjälpen-kit, rustningar och annat. Funktionella specifikationer är i huvudsak reglerna för spelprocessen. Ju bättre det här avsnittet är utarbetat, desto lättare blir det att skapa ett högkvalitativt Android-spel.
Spelinnehåll
Detta är spelets textfyllning. Den beskriver karaktärernas dialoger och vilka vapen som kan användas för att skada, hur mycket hälsa en träff kommer att ta, vilka egenskaper som kommer att öka vid användning av olika utrustning. Den innehåller också detaljerad beskrivning varje sak.
Gränssnitt
Gränssnittet är hur användaren kommer att interagera med spelet. Den innehåller knappar med vilka du kan styra karaktären och menyavsnitt: till exempel spel, poäng, inställningar, toppspelare, hjälp. Om du inte har någon erfarenhet av att skapa Android-applikationer, innan du skapar dina egna, ladda ner från Play Market och analysera populära spel och överför de bästa lösningarna till ditt projekt.
Spelmotor
Kärnan i alla spel är motorn. Det programvara, så att du kan utveckla och driva den. Den innehåller en hel rad program, inklusive en renderingsmotor, en fysikmotor, ljud, animation och mycket mer. För att underlätta processen att skriva program skapar tredjepartsutvecklare sina egna spelmotorer specifikt för Android-applikationer.
Var och en av dem erbjuder olika funktioner: vissa är designade för 3D, andra för 2D, multiplattformar kan stödjas. Det finns ett stort antal sådana motorer, men om du är nybörjare är det bättre att välja en av de mest populära, eftersom alla nödvändiga funktioner kommer att finnas där.
UDK
Vridmoment 2d/3d
Vad är en speldesigner?
Constructor är ett program som kombinerar en spelmotor och en integrerad utvecklingsmiljö. Konstruktören gör utvecklingsprocessen tillgänglig för personer som inte har programmeringskunskaper. Vissa av designerna låter dig skapa spel av vissa genrer, andra har maximal funktionalitet, men kostar mycket mer pengar. För en nybörjarskapare av mobilapplikationer är valet av en designer ett av de mest avgörande ögonblicken, eftersom ödet för den framtida applikationen kommer att bero på dess kapacitet.
Konstruktören låter dig skapa spel av olika genrer för Windows, Android och iOS. Erbjudanden stort val färdiga platser, föremål, karaktärer och ljuddesign, så skapandet av det första Android-spelet kommer inte att ta mycket tid. Användare som är bekanta med programmeringsspråken JS och C++ kan använda den inbäddade GML. Den enda nackdelen är att programmet inte är översatt till ryska.
Slutsats
Att skapa ett Android-spel är inte en lätt, men mycket lönsam affär. Om du bestämmer dig för att utveckla ett spel och tjäna pengar på det, utarbeta idén först. Skriv sedan ett "designdokument" och bestäm dig för en spelmotor som kan maximera dess potential. Därefter kan du fortsätta direkt till att skapa applikationen i konstruktorn.
Video
För att lära dig mer om processen att skapa Android-spel, kolla in en serie videor dedikerade till denna aktivitet.
Hur man snabbt skriver ett Android-spel med Unity
För närvarande kan vem som helst bli en framgångsrik mobilspels- eller applikationsutvecklare utan att göra en enorm insats. Ett exempel på ett sådant fall är Dong Nguyen, som utvecklade Flappy Bird. Spelet hade ingen komplex mekanik eller grafik, men detta hindrade inte det från att bli populärt och ge sin skapare femtio tusen dollar om dagen. Det var dock inget anmärkningsvärt med spelet. Allt som krävdes för att bli framgångsrik var att vara på rätt plats vid rätt tidpunkt och lite tur. Liknande saker kan hända idag, du behöver bara rätt idé.
För att visa hur lätt det är att skriva något sånt här kommer vi idag att skriva vår egen Flappy Bird med Unity på bara 10 minuter.
spelkaraktär
Skapa först ett nytt projekt och se till att 2D-alternativet är valt.
Ladda in din fågelsprite i scenen. Glöm inte att sätta på din fantasi!
Justera sedan storleken på spriten efter eget tycke genom att dra den runt hörnet i den riktning du vill ha. Spriten ska vara synlig i hierarkifönstret till vänster. Alla objekt i scenen är synliga i den, och för tillfället borde det bara finnas två av dem: en kamera och en fågel.
Dra kameran till fågeln och släpp. Kameran ska vara under fågeln, vilket betyder att kameran nu är fågelns "barn". Nu kommer kamerapositionen att vara fixerad i förhållande till fågeln. Om fågeln rör sig framåt gör kameran detsamma.
Välj fågeln igen i scenen eller i hierarkifönstret. Du kommer att se en lista med alternativ och attribut till höger i ett fönster som heter Inspektör. Här kan du hantera olika variabler bundna till ett visst objekt.
Klicka nu på Lägg till komponent. Välj Physics2D > Rigidbody2D - det här är klara Färdiga instruktioner för att applicera gravitation på vår karaktär. Klicka på Constraints i den här panelen och välj sedan freeze rotation Z . Detta kommer att förhindra att fågeln roterar runt med kameran.
På samma sätt lägger du till en Polygon Collider som talar om för Unity var karaktärens gränser går. Tryck på Play och se hur spriten, tillsammans med kameran, faller ner oändligt.
Än så länge går allt bra!
Nu är det dags att börja flyga karaktären, eftersom det inte kommer att vara svårt.
Först måste du skapa ett C#-skript. Skapa en mapp för den (högerklicka någonstans i tillgångar och skapa en "Scripts"-mapp), högerklicka och välj Skapa > C#-skript .
Låt oss kalla det "karaktär". Dubbelklicka på den för att öppna den i din IDE, oavsett om det är MonoDevelop eller Visual Studio. Lägg sedan till följande kod:
Public class Character: MonoBehaviour ( public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // Detta är för initialisering void Start () ( rb = GetComponent(); ) // Uppdatering anropas en gång per frame void Update () ( rb .velocity = new Vector2(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) ( rb.velocity = new Vector2(rb.velocity.x, flapHeight); ) if (transform.position.y > 18 || transform.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }
Den här koden gör två saker. Det får karaktären att röra sig framåt i en hastighet som vi definierar i inspektören och ger intrycket av en fågel i flykt. Metoden Update() anropas upprepade gånger under hela spelet, så vad du än lägger här kommer att köras kontinuerligt. I det här fallet lägger vi till lite hastighet till vårt objekt. Variabeln rb är skriptet RigidBody2D som vi tillämpade på vårt objekt tidigare, så när vi skriver rb.velocity hänvisar vi till objektets hastighet.
Ett tryck på skärmen tolkas av Unity som ett musklick om du använder en mobil enhet. Efter att ha tryckt tvingar vi karaktären att höja sig lite.
Den variabla rörelsehastigheten kommer att ansvara för rörelsehastigheten och den variabla flapHeight - för att öka höjden på fågelns flygning efter varje klick. Eftersom dessa variabler är offentliga kan vi ändra dem utanför skriptet.
Metoden Death() deklareras också offentlig , vilket innebär att andra objekt och skript kan anropa den. Denna metod returnerar helt enkelt karaktärens position till början. Den kommer också att användas varje gång karaktären flyger för högt eller lågt. Du kommer snart att förstå varför det deklareras som offentligt. Linjen rb.velocity = Vector3.noll; behövs för att ta bort fart - vi vill inte att karaktären ska falla snabbare och snabbare efter varje dödsfall, eller hur?
Nu kan du avsluta IDE och lägga till skriptet som en komponent till karaktären. För att göra detta, välj vår fågel och klicka på Lägg till komponent > Skript > Karaktär . Nu kan vi definiera moveSpeed och flapHeight i inspektören (det är vad de offentliga variablerna är till för). Tilldela variabelvärden 3 respektive 5.
Och en sak till: i inspektören måste du lägga till en tagg till karaktären. För att göra detta, klicka där det står Tagg: Otaggat och välj sedan Spelare från rullgardinsmenyn.
Hinder
Låt oss nu lägga till hinder: rör. Någon hittar svamp i rören, och någon hittar sin egen död.
Dra pipen spriten till scenen där du vill att det första hindret ska vara och döp det till pipe_up.
Låt oss nu skapa ett nytt skript som heter Pipe:
Public class Pipe: MonoBehaviour ( privat karaktärstecken; // Behövs för initialisering void Start () ( character = FindObjectOfType(); ) // Uppdatering anropas en gång per ram void Update () ( if (character.transform.position.x - transform.position.x >
Lägg till detta skript till pipe sprite på samma sätt som tidigare. Således kommer röret att återgå till skärmen efter att ha lämnat sin vänstra kant. Vi har inte gjort något här än, men vi återkommer till det.
Metoden OnCollisionEnter2D() anropas varje gång pipen interagerar med ett tecken. Därefter anropas metoden Death() som skapats tidigare, vilket återför spelaren till startpunkten.
Så vi har ett rör som kommer att försvinna då och då och dyka upp igen i andra änden av skärmen. Slå henne, du dör.
inverterade rör
Just nu har vi bara en pipe sprite. Låt oss lägga till en till. För att göra detta, högerklicka i hierarkifönstret, klicka på Nytt 2D-objekt > Sprite och välj sedan den sprite du vill använda. Det är ännu enklare att bara dra filen till scenen igen.
Namnge denna sprite pipe_down . I Inspector, under Sprite Renderer, välj alternativet Vänd Y för att vända röret upp och ner. Lägg till samma RigidBody2D .
Låt oss nu skriva ett nytt C#-skript som heter PipeD . Den kommer att ha liknande kod:
Public class PipeD: MonoBehaviour ( private Character character; //Detta behövs för initialisering void Start() ( character = FindObjectOfType(); ) // Uppdatering anropas en gång per ram void Update() ( if (character.transform.position. x - transform.position.x > 30) ( ) ) void OnCollisionEnter2D(Collision2D other) ( if (other.gameObject.tag == "Player") ( character.Death(); ) ) )
Prefabs
Så den här koden räcker för oss för att göra hela spelet. Vi kan flytta rören till höger sida av skärmen varje gång de försvinner, eller kopiera och klistra in så många rör som vi vill under hela spelet.
Om du går den första vägen, se till att rören är rätt efter slumpmässig generering, och det skulle vara svårt att hålla en rättvis kurs. Efter karaktärens död kunde de dyka upp i kilometer från det första röret!
Om du går den andra vägen, kommer allt att sluta med överdriven minnesförbrukning, med den resulterande nedgången i spelet, och begränsat replay-värde, eftersom. allt stannar på samma plats varje gång.
Låt oss istället använda prefabs. Enkelt uttryckt kommer vi att förvandla våra rör till mallar som vi sedan kan använda för att effektivt skapa fler rör efter önskemål. Om det finns programmerare här, betrakta Pipe-skriptet som en klass och pipes som instanser av detta objekt.
För att göra detta, skapa en ny "Prefabs"-mapp. Dra sedan pipe_up och pipe_down från hierarkifönstret till mappen.
Varje gång du drar ett objekt från den här mappen till scenen kommer det att ha samma egenskaper, så du behöver inte fortsätta lägga till komponenter. Vad mer är, om du ändrar storlek på en komponent i en mapp kommer det att påverka alla rör i spelet, och du behöver inte ändra storlek på var och en individuellt.
Som du kan föreställa dig kommer detta att avsevärt spara våra resurser. Det betyder också att vi kan interagera med objekt från kod. Vi kan instansiera våra rör.
Lägg först till den här koden till det villkorliga uttrycket i metoden Update() för Pipe-skriptet som vi lämnade tomt:
Void Update () ( if (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); Instantiate (gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); ) )
Detta behövs för att skapa en instans av vårt gameObject. Resultatet är en ny identisk kopia. I Unity, när du använder ordet gameObject , hänvisar det till objektet som skriptet för närvarande är bundet till - i vårt fall röret.
Vi återskapar våra pipor i slumpmässiga varianter för att göra det roligare.
Men istället för att göra samma sak i PipeD-skriptet genererar vi båda objekten på samma plats. Således kan vi enkelt ställa in läget för det andra röret i förhållande till det första. Det betyder också att vi behöver mindre kod för PipeD.
Skapa ett offentligt spelobjekt med namnet pipeDown. Uppdatera sedan koden så här:
If (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); float gapRan = Random.Range (0, 3); Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate(pipeDown, new Vector2(character.transform.position.x) + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Destroy(gameObject); )
Gå tillbaka till Unity och dra pipe_down prefab från prefabs-mappen (detta är viktigt!) till platsen där det står "Pipe Down" (märk på hur vårt kamelfodral ersätts med ett mellanslag) till pipe sprite pipe up . Om du kommer ihåg så definierade vi Pipe Down som ett offentligt gameObject , vilket ger oss möjligheten att avgöra vad det här objektet är var som helst - i det här fallet genom inspektören. Genom att välja en prefab för det här objektet ser vi till att när pipen instansieras kommer den att inkludera alla attribut och skript som vi lade till tidigare. Vi skapar inte bara en sprite, utan vi återskapar ett objekt med en kolliderare som kan döda karaktären.
Allt vi lägger till på samma ställe i PipeD-skriptet är bara Destroy(gameObject) , så att pipen självförstörs när den försvinner från vänster sida av skärmen.
Om du startar spelet nu kommer skärmen att avancera automatiskt och du kommer att dö om du träffar någon av rören. Flyg tillräckligt långt och de rören kommer att försvinna och dyka upp igen.
Tyvärr är det ett stort avstånd mellan rören och skärmen ser tom ut. Vi skulle kunna fixa detta genom att lägga till några prefabs till vår scen för att skapa en pipeline av ständigt lekande rör. Det skulle dock vara bättre att generera rören i ett skript. Detta är viktigt, för annars, efter karaktärens död, kommer rören i början av vägen att förstöras, och tomt utrymme kommer igen att bildas.
På så sätt kan vi skapa de första rören under varje spelladdning och återställa allt till sin plats efter karaktärens död.
Oändligt flyg
Låt oss nu skapa de publika variablerna pipe_up och pipe_down i Character-skriptet. Detta ger dig möjligheten att referera till de skapade objekten genom att dra prefabs till karaktärsobjektet, precis som när vi lade till pipe_down till Pipe-skriptet.
Vi måste lägga till dessa variabler:
Public GameObject pipe_up; public GameObject pipe_down;
Sedan skriver vi en metod så här:
Public void BuildLevel() ( Instantiate(pipe_down, new Vector3(14, 12), transform.rotation); Instantiate(pipe_up, new Vector3(14, -11), transform.rotation); Instantiate(pipe_down, new Vector3(26, 14), transform.rotation); Instantiate(pipe_up, new Vector3(26, -10), transform.rotation); Instantiate(pipe_down, new Vector3(38, 10), transform.rotation); Instantiate(pipe_up, new Vector3( 38, -14), transform.rotation); Instantiate(pipe_down, new Vector3(50, 16), transform.rotation); Instantiate(pipe_up, new Vector3(50, -8), transform.rotation); Instantiate(pipe_down, new Vector3(61, 11), transform.rotation); Instantiate(pipe_up, new Vector3(61, -13), transform.rotation); )
Vi kallar det en gång i Update()-metoden och en gång i Death()-metoden.
Efter att spelet har startat anropas Update() och våra pipes placeras enligt den givna konfigurationen. På grund av detta kommer de första hindren alltid att finnas på samma plats. Efter spelarens död kommer rören tillbaka till samma platser.
Gå tillbaka till scenen i Unity och ta bort de två pipes som nu finns där. Ditt "spel" kommer bara att se ut som en tom skärm med en fågel. Tryck på Play och rören kommer att dyka upp, efter de första, kommer deras position att bestämmas slumpmässigt.
Till sist
Det var vad vi gjorde hela spelet! Lägg till en poängräknare, försök att göra den mer original och öka spelets svårighetsgrad allt eftersom. Dessutom kommer det inte att vara överflödigt att göra en meny. En annan bra idé är att förstöra rören på skärmen efter karaktärens död. När du är klar med det – anse att den är redo för release i Play Butik spel i fickan! Det var en gång liknande spel gjort en annan utvecklare mycket rik, vilket bevisar att du inte behöver vara ett programmeringsgeni eller ha en rik utgivare i ryggen för att bli framgångsrik. Du behöver bara en bra idé och tio minuter!
Vill du skriva Android-appar men vet inte var du ska börja? Kolla sedan in vår fantastiska handledning för att lära dig Android-utveckling.
