Hem > Solitaire Solitaire > Att arbeta i Unity3d: grunderna för att skapa spel. Skapa applikationer för Android Unity 3d-spel för Android

Att arbeta i Unity3d: grunderna för att skapa spel. Skapa applikationer för Android Unity 3d-spel för Android

Unity 3D kommer att visa sig vara en oumbärlig assistent för dem som tar ett professionellt förhållningssätt till uppgiften att skapa material av hög kvalitet. Applikationen integrerar färdiga modeller, skript och texturer, som kan kompletteras med eget innehåll - bilder, ljud och videor.

Färdiga produkter skapade i Unity 3D är kompatibla med nästan alla populära plattformar - från mobiltelefoner till SMART TV.

Programfunktioner:

Enhetsinlärningsmotor;
flexibel multifunktionell editor;
hög kompileringshastighet;
lättläst gränssnitt;
kompatibel med ett stort antal plattformar.

Funktionsprincip

För att använda programmet måste du ladda ner Unity Hub-plattformen, och genom den kan du prova funktionerna i den kostnadsfria personliga versionen. Den är tillgänglig för intäktsgenererande volymer på upp till 100 000 USD årligen.

Utöver alternativet Gratis kan du prenumerera på två andra utökade versioner:

Unity Plus (~25 USD per månad) - ger begränsad tillgång till Customer Success Advisor-tjänsten, samlar in information om fel på användarenheter och övervakar recensioner.

Unity Pro (~$125 per månad) är det maximala prenumerationsalternativet. Ger support från professionella utvecklare, låter dig få prioriterad tillgång till support från programskapare och inkluderar förbättrade möjligheter för prestandaövervakning och statistikinsamling.

Konstruktionen av alla spelåtgärder är baserad på en ganska högkvalitativ fysisk kärna av programmet (PhysX), som modellernas beteende beror på. Tack vare möjligheten att importera texturer och objekt kan du lägga till unika egenskaper till produkten eller använda verktyg integrerade av utvecklaren. Det är viktigt att förstå att varje objekt som skapas i denna konstruktor är en specifik uppsättning skript och händelser som du kan hantera själv.

För att arbeta professionellt med Unity 3D behöver du lite tid för att bli bekant med applikationens gränssnitt och funktioner. För att göra detta kan du hitta många videor på Internet eller gå på specialiserade kurser som hålls i många stora städer.

Observera att du måste ha för att arbeta med 3D-grafik modern dator med ett hårdvaruvideokort.

Fördelar:

nästan obegränsad funktionalitet för att skapa projekt;
webbläsares 3D-grafikstöd;
kompatibilitet med spelkonsoler och moderna TV-apparater;
ett stort antal visualiseringsverktyg;
det finns en gratisversion.

Minus:

För att skapa en kvalitetsprodukt krävs specifik kunskap;
det finns ingen möjlighet särskilt mycket finjustering fysiska kärnan i programmet;
Det finns ingen översättning av gränssnittet till ryska.

Du kan ladda ner Unity 3D inte bara för att förbereda en konkurrent till den populära onlineleksaken Juggernaut (som också ritades med verktygen från hjälten i vår recension), utan också för att skapa underbara 3D-presentationer. Det kan ta lite längre tid, men wow-effekten för publiken är garanterad.

För att bekanta dig med plattformens möjligheter, ladda bara ner gratisversionen av Unity 3D. Om du behöver tillgång till källkoden, titta på de betalda versionerna.

Analoger:

Game Editor är en gratis applikation för att skapa spel;
Construct 2 är en populär spelkonstruktör med ett enkelt gränssnitt.
Construct 2 är ett kraftfullt program för att skapa 2D-projekt.

Unity är den motor på vilken de flesta av moderna spel på olika plattformar. Med hjälp av motorn är det möjligt att skapa spel utformade 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, när vi skapar 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 som 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 GameObjects 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 exakt, i Unity-miljön kallas detta ett manus. Modersmålet för att skapa skript är C#, men JavaScript och Boo (en trimmad 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 som är direkt relaterad till klassisk programmering. Utan en tillräcklig kunskapsnivå i programmering kommer du att få 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 främst 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. Utan en Macbook eller liknande enhet kommer släppet av spelet snabbt att stanna och Unity har inget med det att göra, Apple inför själv en liknande begränsning. Slutsatsen är enkel: om du planerar att utveckla iOS 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 den långa processen för spelutveckling både inom Windows och Mac OS X. Det finns redan versioner av editorn för Linux, men vi kan inte räkna med att de fungerar stabilt än. En utvecklare spenderar större delen av sin tid på att skapa ett spel i Unity-redigeraren. Vi måste också lägga mycket tid på att skriva skriptkod, vi kan skapa den antingen i standard MonoDevelop eller i vilken tredjepartsredigerare som helst. Nuförtiden använder de aktivt Visual Studio, såväl som Sublime Text, men bara med rätt konfiguration.

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. I grund och botten är det en plattformsoberoende motor som låter dig utvecklas 3D- Och 2D-spel. Funktionen som skiljer Unity från andra motorer är den låga inträdesbarriären för nybörjare, medan det finns 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.

Det är värt att nämna separat om 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: årsinkomsten eller mängden insamlade medel får inte överstiga 100000$ .
Plus. Bakom $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 mängden insamlade medel får inte överstiga 200000$ .
Proffs. Bakom $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 volym av medel.
Separata versioner för företag (används av stora företag).

För indieutvecklare med små budgetar borde versionen alltså räcka Personlig eller Plus, annars måste du prenumerera Proffs. I den här artikeln kommer vi att använda gratis version för den första lanseringen.

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 en prenumerationstyp. Som nämnts ovan, låt oss välja 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 blir du ombedd att välja vilka komponenter du vill installera. Eftersom vi behöver skapa en applikation för Android, låt oss markera rutan 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 detta återstår bara att välja installationssökväg och börja installera Unity.

Steg 2: Registrera och konfigurera Unity

Efter att ha slutfört installationen och startat Unity uppmanas vi att logga in med vårt konto.

Då blir du återigen ombedd att välja ett abonnemang, vi kommer fortfarande att välja 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 blir du ombedd att göra 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 projektval/skapande. Här måste du klicka 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.

Klicka på när du är klar Skapa projekt att skapa ett projekt. Efter detta öppnas ett redigeringsfönster med en förgenererad scen.

Låt oss inte ta itu med programmerings krångligheter för nu och ta ett färdigt spel som exempel. Det är därför det finns här 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 måste du gå till 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 som indikerar att projektinställningarna kommer att ändras efter import.

När du godkänner 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 Project Explorer. Det här är spelfilerna. Expandera om du vill öppna en scen i redigeraren 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 installerat alla nödvändiga komponenter och därför kan du säkert gå vidare till nästa steg.

För att bygga 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 följa 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 installationsprogrammets instruktioner.
Android SDK. Mest på ett enkelt sätt För att installera den aktuella 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. Installationsprogrammet för Android Studio installerar de grundläggande Android SDK-komponenterna som krävs för Android-utveckling.

Steg 5. Förbereda 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.

I fönstret som visas måste du välja Android och tryck sedan på Byt plattform.

Plattformsbytet informerar oss om att vi kommer att bygga en Android-app. Det betyder att när vi bygger applikationen kommer Unity att skapa APK-fil. Att byta plattform tvingar också Unity att importera alla projekttillgångar igen. Detta tar inte lång tid på ett litet projekt, men tänk på att på större projekt kan denna operation ta lång tid.

Nu måste vi ange paketnamnet för applikationen.

Notera: Paketnamnet är programmets unika identifierare och skrivs i omvänd DNS-stil i formatet com.CompanyName.ProductName. När din app har publicerats på Google Play kan paketnamnet inte ändras.

För att göra detta, gå till menyn Redigera och välj Projektinställningar - Spelare.

Ett fönster öppnas på höger sida av Unity 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 måste du 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. Bygg och kör programmet

Det är dags att bygga din första Unity-applikation. 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 behöver monteras. 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 byggnaden, efter att ha lagt till den kommer du att se den i listan över scener.

Allt du behöver göra är att klicka Bygga, varefter Unity börjar bygga applikationen. Innan du gör detta kan du bli ombedd att välja en mapp där de insamlade programfilerna ska sparas, samt ett namn för APK-filen.

Notera: på det här ögonblicket, om du har alfaversionen installerad i Android SDK Byggverktyg(version 28.0.0-rc1), kommer Gradle att ge ett felmeddelande när du bygger. För att fixa detta, ta helt enkelt bort den här versionen från Android SDK.

Som ett resultat kommer den sammansatta APK-filen att visas i mappen du angav, redo för installation på en emulator eller på en riktig enhet.

Låt oss se vad som finns i den sammansatta APK-filen. För att göra detta kommer vi att använda 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 totalt 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 applikation på Android.

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

Spelar du datorspel? Om ja, då, i processen att passera nästa storsäljande spel, fick du ibland tankar som: "Men här, jag skulle ha gjort det fel!" Vill du själv uppleva rollen som utvecklare? Sedan erbjuder jag dig 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 full utveckling var det nödvändigt att vara 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 mycket uppskattade (och är 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" utvecklare, eftersom ganska bekväma utvecklingsmiljöer har dykt upp, 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å den virtuella scenen och konfigurera alla deras parametrar. Det vill säga programmerarens uppgift är bara att skriva spellogiken korrekt!

Men för att underlätta arbetet måste du betala för en liten ökning av projektets storlek (ibland till och med flera gånger!) i jämförelse med dess analoga, skriven på det gamla "hardcore" sättet. Det är just därför som vissa utvecklare inte gillar motorer eller försöker skriva sina egna, som bara använder de komponenter de behöver...

Men du och jag är långt ifrån riktiga programmerare :) Låt oss därför börja 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 ett färdigt spel för vilken enhet som helst;
relativ enkel motorkontroll;
god funktionsutvidgning genom att ansluta plugins;
relativt liten storlek på den slutliga spelsammansättningen (jämfört med andra motorer).

Huvudtrumfkortet i Unity3D är naturligtvis dess mångsidighet och multiplattform. Du kan porta det färdiga spelet (eventuellt med mindre modifieringar) till antingen en PC (Windows, Linux eller MacOS), eller till Android, eller till 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 vi planerar att utveckla för mobila plattformar eller konsoler). Om du vill skapa ett spel för Windows behöver du inte ladda ner något extra, men eftersom vi ska göra ett spel för Android måste vi också ladda ner Android SDK (Software Development Kit). Jag råder dig att ladda ner SDK i ett ZIP-arkiv för att det ska bli lättare att arbeta med det.

När allt har laddats ner kan du packa upp Android SDK till valfri 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 först måste vi 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ärmdump ovan) kommer vi att bli ombedda att ange mappen för att spara projektet (dess namn kommer att sammanfalla med projektets namn), 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

När projektet har skapats 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 som du vill. Jag har det konfigurerat så här (från vänster till höger och uppifrån och ned):

Hierarkifönster - visar den hierarkiska positionen för aktiva och inaktiva objekt i scenen. Som standard är det enda objektet direkt i listan kameran (huvudkamera).
Scenfönster - visar hela spelscenen och objekt på den (inklusive kameror, ljud, texturer, etc.).
Inspektörsfönster - visar alla egenskaper för ett objekt som valts i hierarkin eller på scenen och låter dig redigera, komplettera eller ta bort dem.
Spelfönster - visas spelvärlden, som är synlig genom kameran och låter dig välja storleken på spelets virtuella testfönster i pixlar. Det låter dig också aktivera maximera spelfönstret till full storlek (Maximera vid spel) och aktivera/inaktivera visningen av olika information för utvecklaren.
Projekt- och konsolfönster. Projektfönstret används för att navigera genom projektresurser: laddade bilder, ljud, modeller, etc. Med det här fönstret (sammanhangsmeny) kan du också skapa nya tomma spelobjekt av olika typer och skript. Konsolfönstret används för att visa felmeddelanden (röda), varningar (gula) och olika felsökningsinformation som du har begärt (grå).
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 köra 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 musik instrument: Indiska folktrummor som kallas "tabla", så för att komma igång, låt oss 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 projektnavigatorfönstret och välja "Mapp" i 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" vad du vill, men det finns minst två namn som är bättre att inte använda, eftersom de är reserverade av motorn. Dessa är namnen Resources och Plugins. I stora projekt skapas mappen Resources direkt och alla spelets "reservdelar" (bilder, ljud, modeller, texturer och prefabs) lagras i den (sorterade i undermappar). Plugins, som namnet antyder, lagrar alla ytterligare tredjepartsfunktionsuppsättningar (så kallade "tillgångar"), av vilka det finns en hel del på Asset Store - en butik med tillägg för Unity3D.

Importera filer och skapa spelobjekt

Innan du skapar en ny spelprojekt Det är tillrådligt 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 genom att helt enkelt dra dem till önskad mapp. Låt oss börja med bilderna...

Efter att bilderna visas i vår Bilder-mapp bör de konfigureras 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 viktigt för spel med HD-grafik), bör vi välja varje bild och i Inspektörsfönstret ändra värdet på parametern "Format" från "Komprimerad" till "Truecolor" i " Standardflik. Du kan också behöva ändra parametern "Max Size" om den är mindre än bildens faktiska bredd (standard - 1024 pixlar). Efter alla ändringar måste du komma ihåg att klicka på knappen "Apply" 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 så är fallet genom att välja kameran 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 kamerans vy, därför måste vi justera storleken på denna vy genom att dra ramen direkt på scenen eller redigera parametern "Size" i Inspector-fö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 konfigurerar 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 minska dem antingen fysiskt i en grafisk editor 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 det med hälften). Det är också lämpligt, 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 huvudsak läggs 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 visas letar vi efter Physics 2D (vanlig 3D-fysik fungerar inte i vårt läge) och där, av alla alternativ, passar "Circle Collider 2D" oss bäst. Vi väljer honom. En grön kontur visas runt vårt objekt, som visar kolliderarens gränser. Allt som återstår är att markera rutan "Är trigger" så att vår kolliderare bara registrerar klick och inte längre interagerar med det omgivande spelutrymmet:

Vi upprepar liknande steg för alla återstående objekt. Endast vår bakgrund kommer att skilja sig från andra objekt. För det kommer vi att använda Box Collider 2D och ställa in Position Z större än noll för att trycka kollideraren och själva bakgrunden i bakgrunden (vi kommer att behöva detta lite 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 anpassa dem lite också:

Om volymnivån för alla ljud justeras initialt behöver du bara stänga av 3D-ljudbehandlingen. I 3D-spel behövs denna bearbetning för att simulera ljudkällan som närmar sig 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 kryssrutan "3D-ljud".

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 från avsnittet "Ljud" till den. När komponenten läggs till, välj motsvarande "Ljudklipp"-knapp och avmarkera kryssrutan "Spela i vaken", som är aktiv som standard:

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 manus är det förmodligen värt att säga några ord om själva manussystemet 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 det lättare att lära sig skript i Unity med JavaScript som exempel. Detta språk är dock inte lika bekvämt som de andra, och i framtiden kommer du med största sannolikhet att behöva lära dig det igen. Därför är det bättre att börja direkt 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 ger tips för snabb input standardmetoder, klasser och funktioner, samt ett syntaxkontrollsystem. Nackdelen för mig var dock skrymmande och hög resursförbrukning. Lyckligtvis i Enhetsinställningar Du kan installera vad som helst som en textredigerare, så jag installerade det lätta och funktionella Notepad++ för mig själv (nästan alla exempel kommer att visas i den).

Och en sista sak. Naturligtvis, utan referensmaterial kommer du inte långt med att bemästra alla krångligheter i motorn, 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 fortfarande ibland instabil);
http://docs.unity3d.com/ru/current/ScriptReference/index.html - officiell manual för scripting på engelska;
http://unity3d.ru/distribution/index.php - ryskspråkigt utvecklarforum för Unity 3D;
http://habrahabr.ru/post/141362/ - en serie lektioner om att skapa tredimensionella spel på Habrahabr;
http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - officiell referensbok om C# från Microsoft på ryska.

Tja, för att inte försena länge, föreslår jag att du skapar det första manuset direkt. Om det finns många skript ä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#-skript". Låt oss kalla vårt nya skript, till exempel, Sounds och öppna det med ett dubbelklick. Genom att ta bort standardmetoderna för uppdatering och start, och sedan ange de nödvändiga, får vi följande typ av skript:

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

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

Längst överst listas de bibliotek som måste anslutas för att skriptet ska fungera (till exempel "användning av Unity.Engine" ansluter själva motorn och "användning av System.samlingar" är ett bibliotek som innehåller ett antal inbyggda- i klasser för att köra skriptet under olika system).
Deklaration av klass och variabler. I C# finns det inget koncept för ett skript 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 praktiskt taget 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 skrivas (förutom temporära, som deklareras i själva skriptet). I praktiken betyder det att åtkomstnivån (privat eller offentlig) och typ (int, float, bool eller, som i vårt skript, AudioClip) måste anges för variabeln.I det här fallet kan du ge variabeln vilket namn som helst Eller så kan du ge det ett värdeattribut omedelbart.
En uppsättning metoder och funktioner. En metod i C# kallas nästan vilken funktion som helst som utför vissa åtgärder. I princip kallas de i litteraturen för 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 inte svårt att förstå dess innebörd, vilket sammanfaller med 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 måste göra dem offentliga (privata kommer inte att visas i redigeraren, och vi måste "hänga" ljud på dem via redigeraren). Och sedan i skriptets brödtext använder vi standardmetoden "void OnMouseDown()". Tidigare har den bara ansvarat för att bearbeta ett musklick, men i nya versioner tolkas det även som en touch på pekskärmen. I den skriver vi villkoren under vilka vi kontrollerar namnen på de pressade kolliderarna och, om vi upptäcker nedtryckningen av en av dem, matar vi ut motsvarande ljud (vi använder standardfunktionen audio.PlayOneShot();).

När du skriver kod, se noga till att alla öppnings- och stängningsparenteser finns, annars får du hela tiden felrapporter i konsolen och kommer inte att kunna köra ditt projekt alls! Var också uppmärksam på användningen av metoder och funktioner i namn stora bokstäver. De är också ofta orsaken till fel. Och, naturligtvis, följ alla tecken (prickar, kolon och parenteser), kort sagt språkets syntax. Det kommer att bli svårt i början, 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 är det bara att applicera vårt manus på föremålen på scenen. Det enklaste sättet att göra detta är, återigen, 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 till. Följaktligen drar vi skriptet till alla objekt som ska låta i spelet och vi kan försöka starta 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 för oss, men det är på något sätt för "skalligt". Något saknas i den... Och åtminstone inskriptionen med namnet som står framför oss! Med andra ord måste du implementera något tydligt 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) fullt närvarande. Det viktigaste är att lära sig hur man använder det! Låt oss titta på hur du kan göra en enkel rubrik med hjälp av GUI i Unity.

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

Låt oss ta en närmare titt på skriptet i skärmdumpen. Här skriver vi bara en publik variabel av en ny typ, GUISyle. Denna typ låter dig visuellt ändra utformningen av de element som denna stil är tilldelad. Stilar är användbara när du har många gränssnittselement av samma typ (till exempel knappar), men de måste ha olika utseende.

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

GUI-skript kan fungera från vilket spelobjekt som helst, men vanligtvis rekommenderas de att "hängas" på kameran, vilket är vad vi kommer att göra genom att dra skriptet till huvudkameraobjektet. Om du nu väljer det i Hierarkifönstret, så kan vi i Inspektörsfönstret se den publika variabeln för vår stil, vilket utökar vilket 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 en knapp måste du ange tre av dess alternativ (Normal - normal vy, Hover - när du håller muspekaren och Aktiv - när du klickar), ställ in indrag och anpassa teckensnittet. Som standard är det enda som finns tillgängligt i Unity 3D. Typsnittet är Arial, men du kan manuellt ladda vilket annat typsnitt som helst i projektet och tillämpa det i fältet "Font" och ställa in alla tillhörande parametrar.

Det som är intressant och samtidigt inte helt bekvämt är att GUI-element inte visas på scenen förrän vi lanserar 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, som ett sista exempel, föreslår jag att du skapar ett hjälpfönster, som vanliga utvecklare vanligtvis tillhandahåller för 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 bifoga en kolliderare till den och skriva ett skript 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 de 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. Du bör också komma ihåg att skinn inte bara existerar som variabler, utan också som separata 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".

Vår andra variabel är logisk (eller med andra ord boolesk). Det kan bara ha två värden: sant eller falskt. 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 ansvara för att visa text 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 en sådan parameter till variabler kan du göra dem statiska och komma åt dem från andra skript!

Men låt oss gå tillbaka till resten av koden. Den redan välbekanta metoden "void OnMouseDown()" här kommer att fungera som en switch för variabeln "isVisible" med ett enkelt villkor. Men efter tillståndet finns det ytterligare en 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 finns ett "+"-tecken mellan alla data.

Längre längs med texten i skriptet 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änssnitt element av typen GUI.Box. Till skillnad från en knapp är en ruta ett inaktivt element och används vanligtvis för att visa olika text- eller grafiska data.

Lägg märke till hur vi ställer in placeringen för lådan. Här indikeras alla värden inte direkt, utan med matematiska uttryck, som faktiskt är en analog till "gummilayout" i webbutveckling. Problemet är att om du 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 för tillfället måste de vara perverterade :(

Det sista steget på vägen till framgång är att sätta upp vår hud. Vi anger skalfilen i skriptvariabeln och väljer sedan denna fil i projektfönstret. Som med andra filer kommer skalinställningarna att visas i Inspektörsfönstret. Här letar vi efter elementet som kan ändras (i vårt fall Box), expanderar det och konfigurerar det på samma sätt som stilen som diskuteras 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 klicka på hjälpknappen för att dölja beskrivningen. För att försvinna eventuella aviseringar är det vanligare att peta på valfritt utrymme än att sikta på knapparna. Och det är här det kommer väl till pass för oss: vi gjorde variabeln "isVisible" statisk, såväl som kollideraren som är fäst vid bakgrundsbilden...

Låt oss återgå till vårt allra första manus ("Ljud"), som spårade knapptryckningar för att spela upp ljud. I den (mer exakt, inuti metoden "void OnMouseDown()") behöver vi bara skriva en rad:

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

Med den här raden sätter vi ett villkor: om namnet på den klickade kollideraren inte är lika med namnet på hjälpknappen, kommer variabeln "isVisible" i "Hjälp"-skriptet att vara lika med "falskt". Du behöver bara se till att variabeln "isVisible" har prefixet "static", annars får vi ett felmeddelande.

Nu när vi startar kommer vi att se att vårt hjälpfönster stängs när vi inte bara klickar på knappen i det övre högra hörnet, utan också när vi trycker på någon ledig del av skärmen. Det enda som kan förbättras är att få fönstret att gömma sig även när du klickar på det... Det här blir din "läxa" ;) Jag kommer bara att säga att GUI-rutan måste bytas ut mot en liknande designad knapp, igen, med inställningsskinn och att skriva en funktion som ändrar variabeln "isVisible". Det är det, jag ska hålla 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 att göra 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 spelet 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", ta fram "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ärmdump nedan). Förresten, här kan du ändra den standardaktiva MonoDevelop-textredigeraren 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 montering. Om det bara finns en scen (som i vårt projekt), så behöver du bara 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 justera önskad ordning genom att dra och släppa:

Nästa steg är att välja byggplattform (vi planerar spelet för Android, vilket betyder att vi väljer det) och klicka på knappen "Spelarinställningar" längst ner. 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 listan med inställningar.

Längst ner, i avsnittet "Övriga inställningar", finns det två nödvändiga parametrar: "Bundle Identifier" och "Bundle Version". Standardversionen är inställd på 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 bygginställningarna efter eget gottfinnande eller inte ändra dem alls. Huvudsaken är att nu kan sammanställningen 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 recensionslektion om att skapa enkla applikationer för Android. Så att du kan upprepa allt vi pratade om kommer jag i slutet av artikeln att ge en länk till ett arkiv där alla spelresurser kommer att lagras i form av en separat mapp (om du vill göra allt från början) och i form av 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" och sedan "Anpassat paket" ange sökvägen till vår fil och klicka 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 vara det :) Som en person som själv behärskade Unity 3D från grunden försökte jag i den här artikeln ge svar på högsta belopp frågor och lyft fram de viktigaste nyanserna av att arbeta med motorn som uppstår till en början. Men kanske kommer detta inte att räcka för vissa, så om du har några frågor kan du kontakta mig antingen direkt via e-post eller på forumet: Jag hjälper till på alla sätt jag kan!

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

P.S. Tillstånd ges att fritt kopiera och citera denna artikel, förutsatt att en öppen aktiv länk till källan anges och att Ruslan Tertyshnys författarskap bevaras.

Utveckling mobilapplikationerär ett av de mest lukrativa yrkena i datorbranschen. Att skapa ett spel på Android kostar flera hundra eller tusen dollar, och vinsten kan nå en miljon dollar. I detta avseende är många människor intresserade av att utveckla applikationer för sina telefoner. I den här artikeln kommer du att lära dig om hur du skapar ett spel på Android från grunden med hjälp av en dator, vilken motor och designer som är bättre att välja.

Ingen framgångsrikt spelär inte komplett utan vacker grafik, så att skapa en 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 utarbetande. 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

Spelet och de viktigaste funktionerna för varje karaktär beskrivs här. Här är också en beskrivning av funktionerna spelobjekt– vapen, första hjälpen-kit, rustningar och annat. Funktionella specifikationer är i huvudsak reglerna för spelet. 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 orsaka skada, hur mycket hälsa en träff kommer att ta och vilka egenskaper som kommer att öka vid användning av olika utrustningar. Finns även här 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 erfarenhet av att skapa applikationer på Android, 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

Grunden för alla spel är motorn. Detta 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 göra processen att skriva program enklare skapar tredjepartsutvecklare sina egna spelmotorer specifikt för Android-applikationer.

Var och en erbjuder olika funktioner: vissa är designade för 3D, andra för 2D och kan stödja flera plattformar. 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?

Designern är ett program som kombinerar en spelmotor och en integrerad utvecklingsmiljö. Designern 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örjare som skapar mobilapplikationer är valet av designer ett av de mest avgörande ögonblicken, eftersom den framtida applikationens öde kommer att bero på dess kapacitet.

Designern 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 ljuddesigner, så att skapa ditt första Android-spel 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 spel på Android är inte en lätt uppgift, men det är väldigt lönsamt. 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 spelmotor som kan maximera sin potential. Efter detta kan du fortsätta direkt till att skapa applikationen i designern.