Skapande av applikationer för Android. Använda Unity för att utveckla applikationer Skapa ett 3d-spel för Android

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:

1. Objektmodeller;
2. Funktionella specifikationer;
3. Spelinnehåll;
4. 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. Detta är programvara som låter dig utveckla och köra 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 skapa android-spel, kolla in videoserien för den här aktiviteten.

Unity är den motor på vilken de flesta av moderna spel på olika plattformar. Genom motorn är det möjligt att skapa spel som är orienterade för att köras på datorer (Windows, Linux, MacOS), mobiltelefoner, surfplattor (Android, iOS) och t.o.m. 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, vi 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 musen, tangentbordet, joysticken 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. Att skapa en unik och populärt spel du måste 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 till iOS-funktion 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 deras stabila arbete. 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.

Hej alla! Efter att ha lärt mig hur man gör spel på den här motorn vill jag lära dig detsamma. Först behöver vi Unity3d själv, valfri 3D-modellredigerare och raka armar som växer från axlarna.

1. Att lära sig programmet

Tänk på skärmdumpen ovan:

• Scenen är din kreativa sandlåda.
• Projekt - här är alla animationer och modeller, ljud och texturer.
• För att installera modeller i det övre verktygsfältet, välj Tillgångar-Importera ny tillgång. Du kan också Assets-Import Package-Custom Package. I det andra fallet måste paketet vara i tillägget .unity.
• Hierarki - alla objekt i scenen. Där skapar man föräldrar till objektet. Flytta bara ett objekt till ett annat i hierarkimenyn så bifogas det. Resultatet blir en slags mapp.
• Verktygsfält - lista över verktyg. Där kan du aktivera 2D,3D-läge.
• Inspektör - en funktion i ett objekt, där du lägger till animationer, skript och mer. Där kan du använda verktygen: flytta kameran, flytta objektet, sträcka ut, rotera objektet.

Nu ser du objektmenyn där du kan lägga till animationer, skript och mer.

Jag tror att med den här menyn kommer du inte att ha problem.
Klicka för att skapa ett objekt.

I allmänhet har vi studerat programmet, snart kommer det att vara möjligt att skriva våra egna spel.

2. Skapa ett enkelt spel

Skapa även berg och gupp. Ladda sedan Characher-kontrollerpaketet i projektet. Sedan söker vi i fönstret med Standard assets-Characters controller-projektet och väljer förstapersonsvy (kapsel) eller tredjepersonsvy (mekaniker).
Om den första personen, lägg den bara på marken. Om från den tredje måste du ladda ner animationen. Jag rekommenderar också att ställa in scenbelysningen på Skapa-riktningsljus.

För att lägga till musik, dra den till önskat objekt.
Spelet är klart, men hur kompilerar man det?

För att göra detta, gå till File-Build settings-player settings (för etikett och namn). Välj en plattform och voila, du är klar. För att göra detta måste du installera Android SDK. Men där måste du ange mappen med SDK, och du behöver inte bara SDK, utan API på önskad nivå (till exempel Android 4.2 har API 17). Till exempel, för att spelet ska vara på Android 4.0+ måste du installera dessa API:er.

I nästa artikel kommer jag att berätta hur du ställer in kontroller för Android eller iOS och lär dig hur du skriver skript själv.

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 diverse 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 för att skapa ditt nya 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 markera 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.

Låt oss inte ta itu med programmeringens krångligheter för nu och ta ett färdigt spel som exempel. 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 Flaxande fågel stil - 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 och välj sedan din operativ system 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. Efter att ha publicerat ansökan i Google Play paketnamnet kan 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: på det här ögonblicket 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 inuti den byggda APK-filen. För att göra detta använder vi verktyget APK-analysator, som ingår i Android Studio,

Storleken på den okomprimerade APK-filen ä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.

Hur skapar man snabbt och relativt enkelt ett enkelt spel eller applikation för Android? Läs om detta i artikeln nedan som handlar om att arbeta med Unity3D-motorn.

Spelar du datorspel? Om så är fallet, då, i färd med att passera nästa spelblockbuster, fick du ibland tankar som: "Men här, jag skulle ha gjort det fel!". Vill du själv bli utvecklare? Då bjuder jag på ett litet men väldigt underhållande "äventyr" ;)

Vad är en motor och varför behövs den?

Tidigare, under de första dagarna av datorer, skapades spel och program med den så kallade "hardcore"-metoden. Det vill säga, för en fullfjädrad utveckling krävdes det att man var en ganska erfaren programmerare som kan sitt programmeringsspråk grundligt och kan skriva nästan hela spelet (inklusive pixelgrafik och specialeffekter!) i ett enkelt Anteckningsblock. Det fanns få sådana människor och de var högt värderade (och värderas fortfarande) ...

Idag har tröskeln för att komma in på temat programmering minskat avsevärt. Och detta underlättas inte bara av tillgången på litteratur och alla typer av utbildningsmaterial, utan också av den allt mer förenklade utvecklingsprocessen. Nuförtiden är det sällsynt att träffa riktiga "hardcore" människor, eftersom det har dykt upp ganska bekväma utvecklingsmiljöer, som kallas "motorer".

Kärnan i motorn är att den låter dig importera alla nödvändiga spelobjekt i ett förenklat visuellt läge, ordna dem på en virtuell scen och konfigurera alla deras parametrar. Det vill säga programmerarens uppgift är bara att skriva spellogiken korrekt!

Du måste dock betala för bekvämligheten med arbetet med en liten ökning av projektets storlek (ibland till och med flera gånger!) i jämförelse med dess motsvarighet, skriven på det gamla "hardcore" sättet. Det är av denna anledning som vissa utvecklare inte gillar motorer eller försöker skriva sina egna, där endast de komponenter de behöver används ...

Men du och jag är långt ifrån riktiga programmerare :) Låt oss därför skapa ett enkelt spel för Android baserat på den populära och kraftfulla Unity3D-motorn.

Komma igång med ett projekt i Unity3D

Så varför valde vi att använda Unity3D:

• förmågan att skapa fullfjädrade 2D- och 3D-spel;
• förmågan att kompilera det färdiga spelet för vilken enhet som helst;
• relativ enkel kontroll av motorn;
• god utökbarhet av funktionalitet genom att ansluta plugins;
• relativt liten storlek på spelets slutmontering (jämfört med andra motorer).

Huvudtrumfkortet i Unity3D är naturligtvis dess mångsidighet och multiplattform. Färdigt spel(kanske med lite justeringar) Du kan porta till PC (Windows, Linux eller MacOS), Android, PlayStation eller XBox! För att göra detta behöver vi bara ladda ner själva motorn, som förresten "väger" mer än en gigabyte och de nödvändiga SDK:erna (om utveckling är planerad för mobila plattformar eller konsol). Om du vill göra ett spel för Windows behöver du inte ladda ner något, men eftersom vi ska göra ett spel för Android kommer vi även behöva ladda ner Android SDK (Software Development Kit). Jag råder dig att ladda ner SDK:n i ett ZIP-arkiv för större bekvämlighet att arbeta med det.

När allt har laddats ner kan du packa upp till valfri Android SDK-mapp som passar dig och sedan fortsätta med att installera själva Unity3D. Det är installerat som alla vanliga Windows-program, så det borde inte vara några problem med installationen. Efter installationen startar motorn och vi måste först skapa ett nytt projekt:

För att göra detta måste vi stänga alla välkomst- och introduktionsfönster och sedan välja "Nytt projekt" från menyn "Arkiv". I fönstret som öppnas (se skärmdumpen ovan) kommer vi att uppmanas att ange projektsparamappen (dess namn kommer att vara detsamma som projektnamnet), importera några standarduppsättningar funktioner (vi behöver dem inte) och ange driftsläge. Välj 2D som läge och klicka på knappen "Skapa". Detta avslutar den förberedande delen av arbetet :)

Motorgränssnitt och projekthierarki

Efter att ha skapat projektet kommer det att laddas in i Unity3D-arbetsytan:

Denna arbetsyta i sig har en modulär struktur och består av flera kapslade fönster som kan flyttas runt som du vill. Jag har det inställt så här (från vänster till höger och uppifrån och ned):

1. Hierarkifönster - visar den hierarkiska positionen för aktiva och inaktiva objekt på scenen. Som standard är det enda objektet direkt i listan huvudkameran.
2. Scenfönster - visar hela spelscenen och objekt på den (inklusive kameror, ljud, texturer, etc.).
3. Inspektörsfönster - visar alla egenskaper för det valda objektet i hierarkin eller på scenen och låter dig redigera, komplettera eller ta bort dem.
4. Spelfönster - visar spelvärlden som är synlig för kameran och låter dig välja storleken på det virtuella spelets testfönster i pixlar. Låter dig också aktivera expansionen av spelfönstret i full storlek (Maximera vid spel) och aktivera/inaktivera visningen av olika information för utvecklaren.
5. Projekt- och konsolfönster. Projektfönstret används för att navigera genom projektresurser: uppladdade bilder, ljud, modeller och så vidare. Även med hjälp av detta fönster (sammanhangsmeny) kan du skapa nya tomma spelobjekt av olika typer och skript. Konsolfönstret används för att visa felmeddelanden (röda), varningar (gula) och diverse felsökningsinformation som du begärt (grå).
6. Fönstret Assets Label är den nedre delen av inspektörsfönstret, som visar en förhandsvisning av objektet eller filen som valts i projektfönstret.

Utöver allt ovan, var uppmärksam på de tre knapparna längst upp i mitten. De låter dig starta ditt projekt, pausa det (ibland användbart vid felsökning för att se vad som görs i hierarkin, till exempel) och följaktligen stänga av det.

Vi kommer att skapa en simulator av ett musikinstrument: indiska folktrummor som kallas "tabla", därför kommer vi att komma igång skapa två tomma mappar i projektet där ljud och bilder kommer att lagras. Du kan skapa en ny mapp genom att anropa snabbmenyn i Project Navigator-fönstret och välja "Mapp" från listan "Skapa".

Här är det värt att säga några ord om hur dessa mappar ska heta. För ett enkelt spel, som vår simulator, kan i princip mapparna "döpas" som du vill, men det finns åtminstone två namn som är bättre att inte använda, eftersom de är reserverade av motorn. Dessa är namnen Resurser och Plugins. I stora projekt skapas mappen Resources direkt och alla spelets "reservdelar" (bilder, ljud, modeller, texturer och prefabs) är redan lagrade i den (sorterade efter undermappar). I plugins, som namnet antyder, lagras alla ytterligare tredjepartsuppsättningar av funktioner (de så kallade "tillgångar" (tillgångar)), av vilka det finns en hel del på Asset Store - en butik för tillägg för Unity3D.

Importera filer och skapa spelobjekt

Innan du skapar ett nytt spelprojekt är det lämpligt att i förväg förbereda alla filer som behövs för dess drift. I vårt fall är dessa filer bilder och ljud. Det enklaste sättet att importera dem till ett projekt är att helt enkelt dra och släppa dem till önskad mapp. Låt oss börja med bilder...

Efter att bilderna har dykt upp i vår Bilder-mapp måste de justeras lite:

Faktum är att Unity3D som standard komprimerar alla bilder som läggs till projektet med kvalitetsförlust. Om vi ​​inte behöver en sådan förlust (särskilt sant för spel med HD-grafik), bör vi välja varje bild och ändra värdet på parametern "Format" från "Komprimerad" till "Truecolor" på fliken "Standard" i Inspektörsfönster. Du kan också behöva ändra parametern "Max Size" om den är mindre än den faktiska bildbredden (standard är 1024 pixlar). Efter alla ändringar måste du komma ihåg att klicka på knappen "Använd" för att tillämpa dem. Vid behov utför vi liknande åtgärder för alla andra bilder.

Låt oss nu skapa spelobjekt från våra bilder. För att göra detta, dra helt enkelt önskad bild till hierarkifönstret. Bilden eller 3D-modellen kommer automatiskt att omvandlas till ett spelobjekt och visas vid startkoordinatpunkten framför kameran.

Först och främst har vi lagt till en bakgrundsbild, som ska visas i helskärm. Du kan kontrollera om det är så genom att välja en kamera i hierarkifönstret och titta på hur dess ram visas. I skärmdumpen ovan kan du se att en del av vår bakgrund förblir utanför kameravyn, så vi måste justera storleken på denna vy genom att dra ramen direkt på scenen eller genom att redigera parametern "Storlek" i Inspektörsfönstret. I vårt fall var vi tvungna att ändra standardvärdet (5) till 5,4.

Det är det, vi rör inte kameran längre, utan lägger till och justerar resten av bilderna. När vi lägger till ser vi att några av dem är för stora för vårt spel. Du kan reducera dem antingen fysiskt i en grafikredigerare eller med hjälp av motorn. Låt oss prova den sista metoden. För att göra detta, välj bilden i hierarkifönstret och i inspektörsfönstret ändra "Skala" värdena för X- och Y-koordinaterna från 1 till 0,5 (det vill säga minska med hälften). På samma ställe är det önskvärt, för att undvika överlappningar, att tilldela alla spelobjekt (förutom bakgrunden) en lagerordning som inte är noll (ordning i lager):

Det sista steget i att förbereda spelobjekt från bilder kommer att vara att "hänga" kolliderar på dem. I Unity3D används kolliderar som interaktionsdetektorer mellan objekt. Det vill säga, i själva verket sätts ett virtuellt skal på vår bild, som kan registrera beröringar på den.

För att lägga till en kolliderare till ett objekt, välj det i hierarkifönstret och klicka sedan på knappen "Lägg till komponent" i inspektörsfönstret. I listan med komponenter som dyker upp letar vi efter Physics 2D (vanlig 3D-fysik fungerar inte i vårt läge) och av alla alternativ är "Circle Collider 2D" den mest lämpliga för oss. Vi väljer honom. Ett grönt streck kommer att visas runt vårt objekt, som visar kolliderarens gränser. Det återstår bara att markera kryssrutan "Är trigger" så att vår kolliderare bara registrerar klick och inte längre interagerar med det omgivande spelutrymmet:

Liknande åtgärder upprepas för alla återstående objekt. Endast vår bakgrund kommer att skilja sig från andra objekt. För detta använder vi en Box Collider 2D och ställer in Position Z till att vara större än noll för att trycka kollideraren och själva bakgrunden i bakgrunden (vi behöver detta senare).

Arbeta med ljud

Med ljud i Unity 3D är allt vid första anblicken något förvirrande. Men låt oss försöka lista ut det i ordning :)

Först och främst måste vi dra alla ljud till mappen Ljud och justera dem lite också:

Om volymnivån för alla dina ljud justeras initialt behöver du bara stänga av 3D-ljudbehandlingen. I 3D-spel behövs denna bearbetning för att simulera ljudkällans närmande när kameran närmar sig den. Men i 2D behöver vi inte detta, så vi väljer varje ljud i tur och ordning och avmarkerar "3D-ljud" från det.

Nu kan vi börja lägga till ljud till spelobjekt. För att göra detta måste vi välja varje knapp i tur och ordning och lägga till en ny "Ljudkälla"-komponent till den från avsnittet "Ljud". När komponenten läggs till, välj motsvarande "Ljudklipp"-knapp och avmarkera kryssrutan "Spela i vaken" som är aktiv som standard (spela upp när den visas):

När alla ljud är kopplade till rätt knappar är det dags för den roliga delen - scripting...

Första manuset

Innan vi börjar analysera vårt första skript är det förmodligen värt att säga några ord om själva skriptsystemet i Unity 3D.

Unity låter dig skriva kod på tre språk samtidigt: JavaScript (mer exakt, dess något modifierade version av UnityScript), C # och Boo. I ett antal böcker och guider kan du hitta åsikten att för nybörjare är scripting i Unity lättare att bemästra med JavaScript som exempel. Det här språket är dock inte lika bekvämt som de andra, och i framtiden kommer du med största sannolikhet att behöva lära dig om. Därför är det bättre att börja omedelbart med att lära sig C # (Boo är också bra, men det finns lite utbildningsmaterial på det).

Nu om var du ska skriva koden. Standardkodredigeraren i Unity 3D är MonoDevelop IDE. Fördelen med denna utvecklingsmiljö är att den har tips för att snabbt ange standardmetoder, klasser och funktioner, samt ett syntaxkontrollsystem. Men för mig var nackdelen volymen och den höga resursintensiteten. Lyckligtvis kan du i Unity-inställningarna ställa in vad som helst som textredigerare, så jag "hängde" det lätta och funktionella Notepad ++ för mig själv (nästan alla exempel kommer att visas i den).

Och den sista. Naturligtvis, utan referensmaterial för att bemästra alla krångligheter i motorn, kommer du inte att gå långt, så här är en lista över flera vettiga internetresurser på ämnet Unity 3D:

• http://docs.unity3d.com/ru/current/Manual/UnityManualRestructured.html - officiell manual för motorn med delvis översättning till ryska (dök upp nyligen och är ibland instabil);
• http://docs.unity3d.com/ru/current/ScriptReference/index.html - officiell skriptreferensmanual på engelska;
• http://unity3d.ru/distribution/index.php - Ryskt forum för Unity 3D-utvecklare;
• http://habrahabr.ru/post/141362/ - en serie lektioner om att skapa tredimensionella spel på Habrahabr;
• http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - Microsofts officiella C#-referens på ryska.

Tja, för att inte dra ut det under lång tid, föreslår jag att omedelbart skapa det första manuset. Under skript, om det finns många av dem, är det bättre att tilldela en separat mapp, men vårt spel kommer att vara enkelt, så vi kan skapa ett skript direkt i projektets rotmapp. För att göra detta, ring upp snabbmenyn i projektfönstret, välj listan Skapa och klicka på "C # Script". Låt oss döpa vårt nya skript, till exempel, Ljud och öppna det med ett dubbelklick. Efter att ha tagit bort standardmetoderna Uppdatera och Start, och sedan, efter att ha registrerat de nödvändiga, får vi följande skript:

Om du inte har konfigurerat om editorn kommer vårt skript att öppnas i MonoDevelop. Låt oss ta en titt på dess struktur...

Faktum är att varje C#-skript består av tre huvuddelar:

1. Längst upp listas de bibliotek som måste anslutas för att skriptet ska fungera (till exempel "använder Unity.Engine" kopplar själva motorns arbete och "använder System.Collections" - ett bibliotek som innehåller ett nummer av inbyggda klasser för att skriptet ska fungera under olika system).
2. Klass- och variabeldeklaration. Det finns inget koncept för ett skript i C# som sådant. Istället används begreppet "klass", som innefattar ett antal metoder och funktioner. Även om det i själva verket i Unity 3D-sammanhang är nästan samma sak :) Det viktigaste att komma ihåg är att klassnamnet måste matcha namnet som vi gav skriptet. Det speciella med variabler i C# är att de måste (förutom temporära, som deklareras i själva skriptet) skrivas. I praktiken innebär det att åtkomstnivån (privat eller offentlig) och typ (int, float, bool eller, som vi har i skriptet, AudioClip) måste anges för variabeln. Samtidigt kan vilket namn som helst ges till variabeln. Eller så kan du omedelbart ge den ett värde.
3. En uppsättning metoder och funktioner. En metod i C# är nästan vilken funktion som helst som utför vissa åtgärder. I princip kallas de i litteraturen om Unity 3D för funktioner, men om vi pratar om C # som ett separat programmeringsspråk, så är det trots allt metoder :). Rena funktioner i Unity är till exempel standardfunktioner för att mata ut ljud, rita GUI-element etc. som används inuti metoder.

Genom att nu känna till strukturen för skriptet är det lätt att förstå dess innebörd, vilket kokar ner till följande... I klassen Sounds (script) deklarerar vi 9 variabler av typen AudioClip med de namn vi behöver för att underlätta särskilja dem. Vi gör dem nödvändigtvis offentliga (privata kommer inte att visas i redigeraren, och vi kommer att behöva "hänga" ljud på dem via redigeraren). Och sedan i skriptets brödtext använder vi standardmetoden "void OnMouseDown ()". Tidigare ansvarade den bara för att bearbeta ett musklick, men i nya versioner tolkas det också som en touch till pekskärmen. I den skriver vi villkoren under vilka vi kontrollerar namnen på de pressade kolliderarna och, om vi upptäcker ett tryck på en av dem, matar vi ut motsvarande ljud (vi använder standardfunktionen audio.PlayOneShot();

När du skriver kod, var noga med att ta med alla öppnande och avslutande parenteser, annars får du ständigt felrapporter i konsolen och kommer inte att kunna köra ditt projekt alls! Var också uppmärksam på användningen av versaler i namnen på metoder och funktioner. De är också ofta orsaken till fel. Och, naturligtvis, observera alla tecken (punkter, kolon och parenteser), kort sagt språkets syntax. Till en början blir det svårt, men med tiden kommer du att börja skriva från början utan misstag!

När skriptet är klart, välj det och tilldela ett annat ljud till varje variabel i Inspektörsfönstret. Nu måste vi bara applicera vårt manus på objekten i scenen. Det enklaste sättet att göra detta, igen, är genom att dra skriptet direkt till det önskade spelobjektet i hierarkilistan:

Om skriptet drogs korrekt, bör det visas i Inspektörsfönstret bredvid objektet som vi drog det på. Följaktligen drar vi skriptet till alla objekt som ska låta i spelet och vi kan försöka köra det. När du klickar på våra spelknappar kommer nu, äntligen, det angivna ljudet att ljuda!

Introduktion till GUI

I princip fungerar spelet redan hos oss, men på något sätt är det för "skalligt". Något saknas i den ... Eller åtminstone en inskription med namnet som ligger framför oss! Med andra ord måste du implementera något slags begripligt användargränssnitt.

Egentligen är GUI en förkortning för engelska. "Graphical User Interface", det vill säga ett grafiskt användargränssnitt. Traditionellt innehåller det sådana komponenter som:

• knappar;
• fönster;
• textområden;
• kryssrutor och/eller radioknappar;
• skjutreglage (rullningslister) etc.

I Unity 3D är allt detta (och till och med något mer än det) fullt närvarande. Det viktigaste är att lära sig hur man använder det! Låt oss ta en titt på hur Unitys GUI kan göra en enkel rubrik.

För att göra detta, skapa ett nytt skript som heter Interface och ändra det enligt följande:

Tänk noga på skriptet i skärmdumpen. Här skriver vi bara en publik variabel av typen GUIStyle, vilket är nytt för oss. Denna typ låter dig visuellt ändra utseendet på de element som denna stil är tilldelad. Stilar är användbara när det finns många gränssnittselement av samma typ (till exempel knappar), men de bör ha ett annat utseende.

Därefter skapar vi en knapp ("GUI.Button"), som har följande syntax: villkor - 4 koordinater (horisontell indrag från vänster kant, vertikal indrag från överkant, bredd, höjd) - synlig text inom citattecken och vidare , valfritt, stilindikation. De nödvändiga funktionerna är skrivna i knappens villkor. I vårt fall registrerade vi övergången till utvecklarens webbplats ("Application.OpenURL("");").

GUI-skript kan fungera från alla spelobjekt, men vanligtvis rekommenderas de att "hänga" dem på kameran, vilket vi kommer att göra genom att dra skriptet till huvudkameraobjektet. Om vi ​​nu väljer den i Hierarkifönstret, kommer vi i Inspektörsfönstret att kunna se den offentliga variabeln för vår stil, och expandera vilken vi kommer att få full tillgång till inställningarna för denna stil!

Vi kan ange textfärg och textur för bakgrunden i alla situationer (för knappen måste du registrera dess tre alternativ (Normal - normal vy, Hover - vid svävning och Aktiv - vid klick), ställ in utfyllnad och justera teckensnittet. Som standard är det enda som är tillgängligt i Unity 3D-teckensnittet Arial, men du kan manuellt ladda vilket annat teckensnitt som helst i projektet och tillämpa det i "Teckensnitt"-fältet och ställa in alla relaterade parametrar.

Det som är intressant och samtidigt inte särskilt bekvämt är att GUI-elementen inte visas på scenen förrän vi startar projektet, så att justera parametrarna för varje element kan ta mycket tid. Låt oss köra projektet och se hur vår knapp skapad ovan kommer att se ut:

Ändra gränssnittet efter villkor och statiska variabler

Vi har redan gjort mycket, men det finns alltid utrymme för förbättringar :) Därför föreslår jag, som ett sista exempel, att skapa ett hjälpfönster, med vilket vanliga utvecklare vanligtvis levererar sina spel och applikationer. För att göra detta, lägg till en bild för en sådan knapp i form av ett frågetecken i mappen med bilder och gör ett spelobjekt av det. Låt oss hänga en kollider på den och skriva ett manus med ett namn, till exempel "Hjälp" med följande innehåll:

I det här skriptet har vi två variabler. Den första variabeln definierar skalet som kommer att användas för alla gränssnittselement som beskrivs i denna klass. Till skillnad från stilar, som vi diskuterade ovan, låter skinn dig ändra utseendet på inte bara det individuella elementet som de är tilldelat, utan alla element av en viss typ på en gång. Dessutom, till skillnad från stilar, tilldelas inte skinn till element, utan deklareras omedelbart för hela metoden och fungerar tills ett annat skal deklareras. Man bör också komma ihåg att skinn inte bara existerar som variabler, utan också som enskilda filer. Därför, innan du deklarerar ett skal, måste du omedelbart skapa det i fönstret "Projekt" från snabbmenyn: "Skapa" - "GUI-skal".

Den andra variabeln vi har är en logisk (eller på annat sätt boolesk). Den kan bara ha två värden: "true" (true) eller "false" (false). På grund av sin binära natur är en sådan variabel perfekt för att implementera alla typer av switchar. I vårt fall kommer det att vara ansvarigt för att visa texten som beskriver vårt spel.

Men om du tittar noga kommer du att märka att den sista variabeln har en underbar parameter - "statisk". Genom att lägga till denna parameter till variabler kan du göra dem statiska och komma åt dem från andra skript!

Men tillbaka till resten av koden. Metoden "void OnMouseDown()" som redan är bekant för oss här kommer att fungera som en switch för variabeln "isVisible" med ett enkelt villkor. Men efter tillståndet finns det en annan funktion. Denna funktion ("Debug.Log();") används för att mata ut "i farten" till konsolen värdena för de variabler vi behöver (vi anger dem utan citattecken inom parentes). Som du kan se kan du i en funktion kombinera både oföränderlig text (skriven inom citattecken) och variabler (utan citattecken). Huvudsaken är att det ska finnas ett "+"-tecken mellan alla data.

Längre in i skriptets text har vi en metod för att rita gränssnittet ("void OnGUI()()"), där vi ser deklarationen av ett nytt skal ("GUI.skin = HelpSkin;") och ett nytt gränssnittselement av typen GUI.Box. Till skillnad från en knapp är en ruta ett inaktivt element och tjänar vanligtvis till att visa olika text- eller grafiska data.

Var uppmärksam på hur vi ställer in placeringen för lådan. Här specificeras inte alla värden direkt, utan med hjälp av matematiska uttryck, som faktiskt är en analog till "flytande layout" i webbutveckling. Problemet är att när man anger de exakta storlekarna på GUI-element vid olika skärmupplösningar kommer de inte att anpassa sig och kan vara antingen för små eller omvänt stora. I nästa version av motorn lovar utvecklarna att göra GUI adaptiv, men än så länge måste vi pervertera :(

Det sista steget på vägen till framgång är att anpassa vår hud. Vi anger skalfilen i skriptvariabeln och väljer sedan denna fil i projektfönstret. Som med andra filer kommer skalinställningar att visas i Inspektörsfönstret. Här letar vi efter elementet som kan ändras (i vårt fall Box), öppna det och ställ in det på samma sätt som stilen som diskuterats ovan:

För att se om vårt skript fungerar korrekt, låt oss köra projektet och försöka klicka på hjälpknappen:

Nu fungerar allt, men det är inte alltid bekvämt att trycka på hjälpknappen för att dölja beskrivningen. Det är mer vanligt att peta in några aviseringar i någon friplatsän att sikta på knapparna. Och det är här vi bara behöver använda det faktum att vi gjorde variabeln "isVisible" statisk, liksom kollideraren hängde på bakgrundsbilden...

Låt oss gå tillbaka till vårt allra första manus ("Ljud"), som spårade knapptryckningar för att spela upp ljud. Det kommer att räcka för oss att bara skriva en rad i den (mer exakt, inuti metoden "void OnMouseDown ()":

if (this.name != "HelpButton")(Help.isVisible = false;)

Med den här raden sätter vi ett villkor: om namnet på den tryckta kollideraren inte är lika med namnet på hjälpknappen, kommer variabeln "isVisible" i "Hjälp"-skriptet att vara lika med "false". Bara det är nödvändigt att variabeln "isVisible" definitivt har efterskriften "static", annars får vi ett fel.

Nu, vid uppstart, kommer vi att se att vårt hjälpfönster stängs när du inte bara klickar på knappen i det övre högra hörnet, utan också när du trycker på någon ledig del av skärmen. Det enda som kan förbättras är att få fönstret att dölja sig när du klickar på det... Det här blir din "läxa";) Jag kan bara säga att GUI-rutan kommer att behöva ändras till en liknande designad knapp, igen , med inställningsskalet och ordinerar en funktion som ändrar variabeln "isVisible". Allt, håll tyst :)

Kompilerar spelet och sparar projektet

Äntligen fungerar allt för oss! Det betyder att det är dags att spara vårt spel och testa det på en riktig enhet. Och för detta måste den kompileras till en körbar fil (för Windows, till exempel i EXE, och för Android, i APK).

Om du vill kompilera ett spel för PC behöver du inte göra några preliminära inställningar. Men för Android måste du först ansluta Android SDK som vi laddade ner i början. Detta görs helt enkelt: gå till menyn "Redigera", anrop "Inställningar" och i fönstret som öppnas, gå till fliken "Externa verktyg". Här letar vi efter raden "Android SDK Location" och i den anger vi sökvägen till det uppackade arkivet med SDK (se skärmdumpen nedan). Förresten, här kan du också ändra den monstruösa MonoDevelop-textredigeraren som är aktiv som standard till din favorit :)

Och nu har sanningens ögonblick kommit! Gå till "Arkiv"-menyn och leta efter "Bygginställningar" där. I fönstret som öppnas måste vi omedelbart lägga till scener för monteringen. Om det bara finns en scen (som i vårt projekt), så räcker det med att klicka på knappen "Lägg till aktuell". Om det finns flera av dem, måste du öppna var och en av dem och lägga till dem i listan över scener på samma sätt, och sedan, genom att dra och släppa, justera önskad ordning:

Nästa steg är att välja byggplattform (vi planerar ett spel för Android, vilket innebär att vi väljer det) och klicka på knappen "Spelarinställningar" nedan. Inspektörsfönstret öppnar ett antal inställningar, av vilka några är obligatoriska eller mycket önskvärda. Det är önskvärt att ange namnen på utvecklarföretaget, programmet och dess ikon (företagsnamn, produktnamn respektive standardikon) högst upp i inställningslistan.

Längst ner, i avsnittet "Övriga inställningar", finns det två nödvändiga parametrar: "Bundle Identifier" och "Bundle Version". Standardversionen är inställd som 1.0, men identifieraren måste skapas manuellt och helst unik. Det bör bestå av tre delar, separerade från varandra med punkter: det reserverade ordet "com", sedan namnet på utvecklarföretaget och i slutet namnet på själva applikationen.

Du kan ändra resten av monteringsinställningarna efter eget gottfinnande eller inte ändra alls. Huvudsaken är att nu kommer sammanställningen redan att kunna starta. För att göra detta, klicka bara på knappen "Bygg" i fönstret "Bygginställningar" och vänta tills programmet ger oss en färdig applikation förpackad i en APK-fil :)

Slutsats

Detta avslutar vår lektionsrecension om att skapa de enklaste applikationerna för Android. Så att du kan upprepa allt vi pratade om kommer jag i slutet av artikeln att ge en länk till arkivet, som kommer att lagra alla resurser i spelet som en separat mapp (om du vill göra allt från början) och som en fil med tillägget unitypackage. Det senare låter dig importera hela projektet till Unity på en gång, inklusive beroenden, etc.

För att importera vårt projekt (och, förresten, alla plugins som laddats ner från Internet eller Assets Store), måste du gå till menyn "Tillgångar", välj "Importera paket" -objektet och i det "Anpassat paket", Ange sedan sökvägen till vår fil och tryck på knappen "Importera". Förresten, du kan göra en fullständig säkerhetskopia av ditt projekt, spara det i ett sådant unitypackage, från samma meny ("Tillgångar") genom att klicka på "Exportera paket".

Det verkar som allt :) Som en person som själv behärskade Unity 3D från grunden, försökte jag i artikeln svara på det maximala antalet frågor och lyfta fram de viktigaste nyanserna av att arbeta med motorn som uppstår till en början. Men, kanske, detta kommer inte att räcka för någon, därför, om du har några frågor, kan du kontakta mig antingen direkt via e-post eller på forumet: jag hjälper dig på alla sätt jag kan!

Jag önskar er alla lycka till och framgångsrikt genomförande av alla projekt!

P.S. Det är tillåtet att fritt kopiera och citera denna artikel, förutsatt att en öppen aktiv länk till källan anges och författarskapet till Ruslan Tertyshny bevaras.