Android-ի համար հավելվածների ստեղծում։ Unity-ի օգտագործումը հավելվածներ մշակելու համար 3D խաղի ստեղծում Android-ի համար

Զարգացում բջջային հավելվածներհամակարգչային արդյունաբերության ամենաշահութաբեր զբաղմունքներից է։ Android-ով խաղի ստեղծումն արժե հարյուրավոր կամ հազարավոր դոլարներ, իսկ շահույթը կարող է հասնել մինչև մեկ միլիոն դոլարի: Այս առումով շատերը հետաքրքրված են հեռախոսի համար հավելվածների մշակմամբ։ Այս հոդվածում դուք կսովորեք, թե ինչպես կարելի է զրոյից ստեղծել Android խաղ՝ օգտագործելով համակարգիչը, որը շարժիչն ու դիզայներն ավելի լավ է ընտրել:

Ոչ ոք հաջող խաղչի կարող անել առանց գեղեցիկ գրաֆիկայի, ուստի դիզայնի ստեղծումը զարգացման կարևորագույն փուլերից մեկն է: Android OS-ի դիզայնն իրականացվում է «նախագծային փաստաթղթի» կամ դիզայնի փաստաթղթի միջոցով: Պետք է սկսել խաղալիք ստեղծել՝ դրա մանրամասն ուսումնասիրությամբ։ Ֆայլը պարունակում է.

  1. Օբյեկտների մոդելներ;
  2. Ֆունկցիոնալ բնութագրեր;
  3. Խաղի բովանդակություն;
  4. Ինտերֆեյս.

Եկեք ավելի մանրամասն քննարկենք կետերից յուրաքանչյուրը:

Օբյեկտների մոդելներ

Սա տեղեկատվություն է յուրաքանչյուր կետի ֆունկցիոնալության մասին: Օբյեկտների մոդելները պատասխանատու են իրեր գնելու և վաճառելու ունակության, ինչպես նաև կերպարների խաղային բնութագրերի բարելավման համար:

Ֆունկցիոնալ բնութագրեր

Այն նկարագրում է խաղը, յուրաքանչյուր կերպարի հիմնական առանձնահատկությունները: Այն նաև նկարագրում է առանձնահատկությունները խաղային իրեր- զենքեր, առաջին օգնության փաթեթներ, զրահներ և այլն: Ըստ էության, ֆունկցիոնալ բնութագրերը այն կանոններն են, որոնցով տեղի է ունենում խաղի գործընթացը: Որքան լավ մշակվի այս բաժինը, այնքան ավելի հեշտ կլինի ստեղծել բարձրորակ Android խաղ:

Խաղի բովանդակությունը

Սա խաղի տեքստային լրացումն է։ Այն նկարագրում է հերոսների երկխոսությունները և այն, թե ինչ զենքեր կարող են օգտագործվել վնաս պատճառելու համար, որքան առողջություն կպահանջվի հարվածը, ինչ հատկանիշներ կբարձրանան տարբեր սարքավորումներ օգտագործելիս: Այն նաև պարունակում է մանրամասն նկարագրությունյուրաքանչյուր տարր:

Ինտերֆեյս

Ինտերֆեյսը այն է, թե ինչպես է օգտատերը փոխազդում խաղի հետ: Այն ներառում է կոճակներ, որոնցով կարող եք կառավարել կերպարը, և մենյուի բաժիններ՝ օրինակ՝ խաղալ, միավոր, կարգավորումներ, լավագույն խաղացողներ, օգնություն: Եթե ​​Android հավելվածներ ստեղծելու փորձ չունեք, ապա նախքան ձեր սեփականը ստեղծելը, ներբեռնեք Play Market-ից և վերլուծեք հայտնի խաղերը և լավագույն լուծումները փոխանցեք ձեր նախագծին:

Խաղի շարժիչ

Ցանկացած խաղի առանցքը շարժիչն է: Սա ծրագրաշար է, որը թույլ է տալիս մշակել և գործարկել այն: Այն պարունակում է ծրագրերի մի ամբողջ շարք, ներառյալ ռենդերային շարժիչ, ֆիզիկայի շարժիչ, ձայն, անիմացիա և շատ ավելին: Ծրագրեր գրելու գործընթացը հեշտացնելու համար երրորդ կողմի մշակողները ստեղծում են իրենց խաղային շարժիչները հատուկ Android հավելվածների համար:

Նրանցից յուրաքանչյուրն առաջարկում է տարբեր առանձնահատկություններ՝ մի քանիսը նախատեսված են 3D-ի համար, մյուսները՝ 2D-ի համար, բազմահարթակ կարող է աջակցվել: Նման շարժիչների հսկայական քանակ կա, բայց եթե սկսնակ եք, ապա ավելի լավ է ընտրել ամենահայտնիներից մեկը, քանի որ այնտեղ առկա կլինեն բոլոր անհրաժեշտ գործառույթները:

UDK

Ոլորող մոմենտ 2d/3d

Ի՞նչ է խաղի դիզայները:

Constructor-ը ծրագիր է, որը համատեղում է խաղի շարժիչը և ինտեգրված զարգացման միջավայրը: Կոնստրուկտորը զարգացման գործընթացը հասանելի է դարձնում այն ​​մարդկանց, ովքեր չունեն ծրագրավորման հմտություններ: Դիզայներներից ոմանք թույլ են տալիս ստեղծել որոշակի ժանրերի խաղեր, մյուսներն ունեն առավելագույն ֆունկցիոնալություն, բայց արժեն շատ ավելի մեծ գումար: Բջջային հավելվածների սկսնակ ստեղծողի համար դիզայների ընտրությունը ամենակարևոր պահերից մեկն է, քանի որ ապագա հավելվածի ճակատագիրը կախված կլինի նրա հնարավորություններից:

Կոնստրուկտորը թույլ է տալիս ստեղծել տարբեր ժանրերի խաղեր Windows-ի, Android-ի և iOS-ի համար։ Առաջարկներ մեծ ընտրությունպատրաստի վայրեր, առարկաներ, կերպարներ և ձայնային ձևավորում, ուստի առաջին Android խաղի ստեղծումը շատ ժամանակ չի խլի: JS և C++ ծրագրավորման լեզուներին ծանոթ օգտատերերը կարող են օգտագործել ներկառուցված GML-ը: Միակ թերությունն այն է, որ ծրագիրը թարգմանված չէ ռուսերեն։

Եզրակացություն

Android-ով խաղի ստեղծումը հեշտ, բայց շատ շահավետ բիզնես չէ: Եթե ​​որոշել եք խաղ մշակել և դրա վրա գումար աշխատել, նախ մշակեք գաղափարը: Հաջորդը, գրեք «նախագծային փաստաթուղթ» և որոշեք խաղի շարժիչը, որը կարող է առավելագույնի հասցնել իր ներուժը: Դրանից հետո կարող եք ուղղակիորեն անցնել հավելվածի ստեղծմանը կոնստրուկտորում:

Տեսանյութ

Գործընթացի մասին ավելին իմանալու համար Android խաղերի ստեղծում, դիտեք այս գործունեության տեսաշարը:

Միասնությունն այն շարժիչն է, որի վրա մեծ մասը ժամանակակից խաղերտարբեր հարթակներում։ Շարժիչի միջոցով հնարավոր է ստեղծել խաղեր, որոնք ուղղված են համակարգիչների (Windows, Linux, MacOS), բջջային հեռախոսների, պլանշետային համակարգիչների (Android, iOS) և նույնիսկ աշխատելու համար: խաղային կոնսուլներ PlayStation, Xbox, Nintendo.

Ինչպե՞ս ստեղծել խաղեր Unity-ում:

Միասնությունը հիմնված է բաղադրիչի վրա հիմնված հայեցակարգի վրա: Իրականում ցանկացած խաղ բաղկացած է լրացուցիչ բաղադրիչներով նոսրացված առարկաների զանգվածից։ Օրինակ՝ պլատֆորմերի ստեղծման ժամանակ մենք ստեղծում ենք GameObject, դրան լրացուցիչ կցում ենք գրաֆիկական բաղադրիչ, որը պատասխանատու է նիշը ցուցադրելու համար, իսկ կառավարման բաղադրիչ՝ ապահովում է կերպարի կառավարում մկնիկի, ստեղնաշարի, ջոյստիկի կամ սենսորային էկրան: Շարժիչը սահմանափակումներ չի դնում նման մոդուլների քանակի վրա: Մենք կարող ենք GameObject-ին ավելացնել այնքան բաղադրիչ, որքան անհրաժեշտ է: Շարժիչի վրա բոլոր աշխատանքները հիմնված են հենց GameObject-ի ստեղծման և դրանց վրա համապատասխան բաղադրիչների կիրառման վրա:

Սկսնակներին կարող են մոլորեցնել գործընթացի ակնհայտ պարզությունը, թեև դա այդպես չէ: Ստեղծել եզակի և հայտնի խաղպետք է զրոյից գրել շատ բաղադրիչներ: Ավելի կոնկրետ, Unity միջավայրում սա կոչվում է սցենար: Սկրիպտավորման մայրենի լեզուն C# է, սակայն JavaScript-ը և Boo-ն (Python-ի կրճատված տարբերակը) նույնպես մասամբ օգտագործվում են: Ձեր սեփական բաղադրիչների ստեղծումը հեշտ չէ, նույնիսկ կարելի է ասել, որ դա բարդ ընթացակարգ է, որն ուղղակիորեն կապված է դասական ծրագրավորման հետ: Առանց ծրագրավորման գիտելիքների բավարար մակարդակի, դժվար կլինի:

Աջակցվող հարթակներ

Շատ խոշոր նախագծեր նախընտրում են Unity-ն շարժիչի հետ համատեղելի հարթակների հսկայական ցանկի պատճառով: Ավարտված հավելվածը կարող է գործարկվել ցանկացած համակարգչի օպերացիոն համակարգում, հայտնի բջջային հարթակներում և SmartTV-ում: Ինչ կարող ենք ասել, նույնիսկ բրաուզերի խաղեր և հավելվածներ հատուկ հարթակների համար ( ինչպես Tizen OS-ն) հիմնականում զարգացած են Unity-ում։

Այնուամենայնիվ, այստեղ ամեն ինչ այնքան էլ հարթ չէ։ Անհրաժեշտության դեպքում կարող եք գրել կոնկրետ ալգորիթմներ՝ հիմնված ցածր մակարդակի կոդի վրա, նույն Android-ի համար պետք է ունենալ Java-ի մանրակրկիտ իմացություն։

Նույնը վերաբերում է iOS-ին: Ուրիշ մեկը iOS-ի առանձնահատկությունըոր դրա համար հնարավոր է մշակել միայն Apple-ի համակարգչից կամ պլանշետից։ Macbook-ի կամ նմանատիպ սարքի բացակայության դեպքում խաղի թողարկումը արագ կդադարի, և Unity-ն դրա հետ կապ չունի, Apple-ն ինքն է դնում նմանատիպ սահմանափակում։ Եզրակացությունը պարզ է՝ եթե ծրագրերում կա iOS-ի մշակում, ապա պետք է նախօրոք ընտրել համապատասխան սարք հավաքման համար։

Ինչպե՞ս և որտեղ զարգացնել խաղ շարժիչի վրա:

Մենք կարող ենք խաղերի մշակման երկար գործընթաց իրականացնել ինչպես Windows-ի, այնպես էլ Mac OS X-ի շրջանակներում: Արդեն կան խմբագրիչի տարբերակներ Linux-ի համար, բայց առայժմ չենք կարող հույս դնել դրանց կայուն աշխատանքի վրա: Մշակողը ժամանակի մեծ մասը ծախսում է խաղ ստեղծելու Unity խմբագրիչի ներսում: Մենք դեռ շատ ժամանակ ունենք սցենարի կոդը գրելու համար, այն կարող ենք ստեղծել կա՛մ ստանդարտ MonoDevelop-ում, կա՛մ որևէ երրորդ կողմի խմբագրիչում: Այժմ նրանք ակտիվորեն օգտագործում են Visual Studio-ն, ինչպես նաև Sublime Text-ը, բայց միայն համապատասխան կոնֆիգուրացիայով։

Բարեւ բոլորին! Սովորելով այս շարժիչով խաղեր պատրաստել, ես ուզում եմ նույնը սովորեցնել ձեզ: Նախ, մեզ անհրաժեշտ է հենց Unity3d-ը, ցանկացած 3D մոդելի խմբագրիչ և ուղիղ ձեռքեր, որոնք աճում են ուսերից:

1. Ծրագրի ուսուցում

Սկսնակների համար խորհուրդ եմ տալիս տեղադրել Monodevelop! Եկեք հասկանանք, թե ինչ է Միասնությունը։ Unity-ն բազմահարթակ խաղերի մշակման միջավայր է: Նրա պարզության և հասկանալիության պատճառով է, որ յուրաքանչյուր երրորդ մարդ գոնե մեկ անգամ խաղ է սարքել դրա վրա:

Դիտարկենք վերևի սքրինշոթը.

  • Բեմը ձեր ստեղծագործական ավազատուփն է:
  • Նախագիծ - ահա բոլոր անիմացիաներն ու մոդելները, հնչյունները և հյուսվածքները:
  • Վերևի գործիքագոտում մոդելներ տեղադրելու համար ընտրեք Ակտիվներ-Ներմուծել նոր ակտիվ: Կարող եք նաև Ակտիվներ-Ներմուծել Փաթեթ-Պատվերով Փաթեթ: Երկրորդ դեպքում փաթեթը պետք է լինի .unity ընդլայնման մեջ։
  • Հիերարխիա - տեսարանի բոլոր օբյեկտները: Այնտեղ դուք ստեղծում եք ծնողներ օբյեկտի համար: Պարզապես հիերարխիայի ընտրացանկում օբյեկտը տեղափոխեք մյուսը, և այն կկցվի: Արդյունքը կլինի մի տեսակ թղթապանակ:
  • Գործիքադարակ - գործիքների ցանկ: Այնտեղ կարող եք միացնել 2D, 3D ռեժիմը:
  • Տեսուչ - օբյեկտի հատկանիշ, որտեղ ավելացնում եք անիմացիաներ, սցենարներ և այլն: Այնտեղ կարող եք օգտագործել գործիքները՝ տեղափոխել տեսախցիկը, շարժել առարկան, ձգվել, պտտել առարկան։


Այժմ դուք տեսնում եք օբյեկտի ընտրացանկը, կարող եք ավելացնել անիմացիա, սցենարներ և այլն:

Կարծում եմ, որ այս մենյուով դուք խնդիրներ չեք ունենա։
Կտտացրեք ցանկացած օբյեկտ ստեղծելու համար:

Ընդհանուր առմամբ, մենք ուսումնասիրել ենք ծրագիրը, շուտով հնարավոր կլինի գրել մեր սեփական խաղերը։

2. Ստեղծեք պարզ խաղ

Նախ, եկեք ստեղծենք Create-Terrain տարածք: Ավելացնել խոտ և ծառեր: Աջ կողմում սեղմելով գետնին, կհայտնվի պատուհան, ընտրեք ծառեր, խոտ:


Ստեղծեք նաև սարեր և բլուրներ: Այնուհետև բեռնեք Characher վերահսկիչի փաթեթը նախագծի մեջ: Այնուհետև պատուհանում փնտրում ենք «Standard assets-Characters» վերահսկիչ նախագծով և ընտրում առաջին դեմքի տեսքը (կապսուլա) կամ երրորդ անձի տեսքը (մեխանիկ):
Եթե ​​առաջին մարդը, ապա պարզապես դրեք այն գետնին: Եթե ​​երրորդից, ապա պետք է ներբեռնել անիմացիան։ Ես նաև խորհուրդ եմ տալիս տեսարանի լուսավորությունը դնել Ստեղծել-ուղղորդման լույսի վրա:


Երաժշտություն ավելացնելու համար այն քաշեք ցանկալի տարրի վրա:
Խաղը պատրաստ է, բայց ինչպե՞ս այն կազմել։

Դա անելու համար անցեք File-Build settings-player settings (պիտակի և անվան համար): Ընտրեք հարթակ և voila, դուք ավարտեցիք: Դա անելու համար հարկավոր է տեղադրել Android SDK-ն: Բայց այնտեղ դուք պետք է նշեք SDK-ով թղթապանակը, և ձեզ հարկավոր է ոչ միայն SDK, այլ ցանկալի մակարդակի API (օրինակ, Android 4.2-ն ունի API 17): Օրինակ, որպեսզի խաղը լինի Android 4.0+-ում, դուք պետք է տեղադրեք այս API-ները։

Հաջորդ հոդվածում ես ձեզ կպատմեմ, թե ինչպես կարգավորել Android-ի կամ iOS-ի համար նախատեսված կարգավորումները և սովորել, թե ինչպես ինքներդ գրել սցենարներ:

Գրառման դիտումներ՝ 19 374

Մենք խոսեցինք այն մասին, թե ինչպես կարող եք ստեղծել ձեր սեփական խաղը Android-ում՝ օգտագործելով Unreal Engine: Այս հոդվածում մենք կանդրադառնանք մեկ այլ նույնքան հայտնի խաղի զարգացման շարժիչին. միասնություն։

Unity-ն շատ հայտնի շարժիչ է ինդի մշակողների շրջանում: Իրականում դա խաչաձև պլատֆորմային շարժիչ է, որը թույլ է տալիս զարգացնել 3D- և 2D- խաղեր. Առանձնահատկությունը, որը առանձնացնում է Unity-ն այլ շարժիչներից, ցածր մուտքի շեմն է սկսնակների համար, մինչդեռ ունենալով հարուստ գործիքակազմ պրոֆեսիոնալների համար: Cross-platform-ը թույլ է տալիս մշակել հավելվածներ ցանկացած հարթակի համար՝ սկսած սեղանադիր խաղերից մինչև բջջային:

Առանձին-առանձին, հարկ է նշել բաժանորդային համակարգը, քանի որ Unity-ն ամբողջովին անվճար արտադրանք չէ: Բաժանորդագրությունների մի քանի տեսակներ կան.

  • Անձնական. Անվճար տարբերակ, որը պարունակում է շարժիչի բոլոր հիմնական հատկանիշները: Այն ունի հետևյալ սահմանափակումը՝ տարեկան եկամուտը կամ հավաքագրված միջոցների չափը չպետք է գերազանցի 100000$ .
  • Գումարած. Պեր $35 ամսականՏրամադրվում են տարբեր հաշվետվություններ և վերլուծություններ, ինչպես նաև էկրանը փոխելու հնարավորություն, 20% -րդ զեղչը գնումների դեպքում Ակտիվների խանութև տարբեր փոքր առավելություններ: Այն ունի հետևյալ սահմանափակումը՝ տարվա եկամուտը կամ հավաքագրված միջոցների չափը չպետք է գերազանցի 200000$ .
  • Pro. Պեր $125 ամսականներառում է տարբերակի բոլոր առավելությունները Գումարածև լրացուցիչ մասնագիտական ​​սպասարկում և պրեմիում աջակցություն: Շրջանառության կամ գումարի չափի սահմանափակումներ չկան:
  • Առանձին տարբերակներ բիզնեսի համար (օգտագործվում են խոշոր ընկերությունների կողմից):

Այսպիսով, փոքր բյուջե ունեցող ինդի մշակողները պետք է գոհ լինեն տարբերակից Անձնականկամ Գումարածհակառակ դեպքում դուք պետք է բաժանորդագրվեք Pro. Այս հոդվածում մենք կօգտագործենք անվճար տարբերակառաջին վազքի համար:

Քայլ 1 Տեղադրեք Unity

Unity-ի տեղադրումը սկսելու համար դուք պետք է գնաք Unity Store-ի կայք, որտեղ ձեզ կառաջարկվի ընտրել բաժանորդագրության տեսակը: Ինչպես նշվեց վերևում, մենք ընտրում ենք Անձնական.

Այնուհետև ձեզ կառաջարկվի ընդունել օգտագործման պայմանները և ներբեռնել տեղադրիչը: Կարող եք նաև ստուգել Համակարգի պահանջներըաշխատել Unity-ի հետ:

Տեղադրիչը գործարկելուց հետո ձեզ կառաջարկվի ընտրել, թե որ բաղադրիչները տեղադրել: Քանի որ մենք պետք է ստեղծենք Android հավելված, մենք կստուգենք վանդակը Android Build Աջակցություն. Նաև ցանկության դեպքում Unity-ի փոխարեն կարող եք տեղադրել Visual Studio Community 2017 թվրա ծրագրավորման համար C#.

Դրանից հետո մնում է միայն ընտրել տեղադրման ուղին և սկսել Unity-ի տեղադրումը։

Քայլ 2. Unity գրանցում և կարգավորում

Տեղադրումն ավարտելուց և Unity-ն գործարկելուց հետո մեզ հուշում են մուտք գործել մեր հաշիվ:

Այնուհետև նորից ձեզ կառաջարկվի ընտրել բաժանորդագրություն, մենք նաև կկենտրոնանանք Անձնականի վրա: Այս դեպքում դուք պետք է հաստատեք, որ ընկերության տարեկան եկամուտը 100,000 ԱՄՆ դոլարից պակաս է, կամ որ Unity-ն օգտագործվում է վերապատրաստման նպատակով:

Վերջում առաջարկվում է փոքրիկ հարցում անել, որում պետք է պատասխանել, թե ինչ եք անում և ինչ նպատակով եք տեղադրում Unity։

Քայլ 3. Ստեղծեք նոր նախագիծ

Միասնությունը կարգավորելուց հետո մենք հայտնվում ենք էկրանին նախագիծ ընտրելու / ստեղծելու համար: Սեղմեք այստեղ Նորձեր նոր նախագիծը ստեղծելու համար:

Դրանից հետո, երևացող պատուհանում, ձեզ խնդրում են մուտքագրել նախագծի անվանումը և այն գրացուցակը, որտեղ այն կտեղակայվի: Նաև մի մոռացեք նշել վանդակը 3Dխմբագրիչը 3D ռեժիմում օգտագործելու համար:

Երբ դա ավարտվի, սեղմեք Ստեղծել նախագիծնախագիծ ստեղծելու համար։ Դրանից հետո խմբագրի պատուհանը կբացվի նախապես ստեղծված տեսարանով:

Եկեք առայժմ չզբաղվենք ծրագրավորման բարդություններով և որպես օրինակ վերցնենք ավարտված խաղը։ Դրա համար կա Ակտիվների խանութ, որը պարունակում է հսկայական քանակությամբ պատրաստի մոդելներ, անիմացիաներ, հնչյուններ (և նույնիսկ խաղեր), ինչպես վճարովի, այնպես էլ անվճար:

Ակտիվների խանութը բացելու համար անհրաժեշտ է ցանկում Պատուհանընտրել Ակտիվների խանութ(ստեղների համադրություն ctrl-9).

Խանութի պատուհանը կբացվի։ Մուտքագրեք որոնման տողում» Flappy bird ոճի օրինակ խաղև բացեք անվճար օրինակ, որը մենք կօգտագործենք մեր նախագծում։

Սեղմելով Բեռնելև այդպիսով ներբեռնելով այն, այնուհետև կարող եք ներմուծել այն ձեր նախագիծ: Դա անելու համար սեղմեք Ներմուծում, որից հետո կհայտնվի նախազգուշացում, որ ներմուծումից հետո նախագծի կարգավորումները կփոխվեն։

Ներմուծման համաձայնությունից հետո կտեսնեք մի պատուհան, որտեղ դուք պետք է ընտրեք, թե որ բաղադրիչները ներմուծել: Ընտրեք բոլորը և սեղմեք Ներմուծում.

Ներմուծումն ավարտվելուց հետո դուք կտեսնեք նոր ֆայլերը Project Browser-ում: Սրանք խաղի ֆայլերն են: Տեսարանը խմբագրում բացելու համար ընդլայնեք Flappy թռչունոճը - տեսարաններև կրկնակի կտտացրեք Հիմնական.

Արդյունքում խաղի տեսարանը կհայտնվի 3D խմբագրիչի պատուհանում։

Դուք կարող եք ստուգել, ​​թե ինչպես է խաղն աշխատում հենց Unity-ում՝ սեղմելով կոճակի վրա խաղալխմբագրի պատուհանի վերևում:

Քայլ 4 Կազմաձևեք Android գործիքները

Նշում:եթե դուք օգտագործում եք android ստուդիա, ապա դուք արդեն ունեք ամեն ինչ տեղադրված անհրաժեշտ բաղադրիչներև այնպես որ կարող եք ապահով կերպով անցնել հաջորդ քայլին:

Ստացված խաղը Android-ում հավաքելու համար անհրաժեշտ է տեղադրել հետևյալ գործիքները.

  • Java Development Kit (JDK):Այն կարող եք ներբեռնել Java կայքից։ Սեղմելով հղման վրա՝ կտեսնեք հենց վերևում Java հարթակ (JDK), սեղմեք Բեռնելմակագրության կողքին, ապա ընտրեք ձեր օպերացիոն համակարգև սկսեք ներբեռնել: Դրանից հետո պարզապես հետևեք տեղադրողի հրահանգներին:
  • Android SDK. առավելապես պարզ ձևովվերջին տարբերակը տեղադրելու համար պետք է ներբեռնել Android Studio-ն, որով գալիս է այս SDK-ն: Դա անելու համար գնացեք Android Studio-ի կայք և սեղմեք Ներբեռնեք Android Studio-ն. Android Studio-ի տեղադրիչը տեղադրում է Android SDK-ի հիմնական բաղադրիչները, որոնք անհրաժեշտ են Android-ի մշակման համար:

Քայլ 5. Պատրաստեք նախագիծը գործարկման համար

Նախ, դուք պետք է փոխեք զարգացման հարթակը Android-ի: Դա անելու համար Unity-ում բացեք «Ֆայլ» ընտրացանկը և ընտրեք «Կառուցել կարգավորումներ»:

Բացվող պատուհանում ընտրեք Androidիսկ հետո սեղմեք անջատիչ հարթակ.

Պլատֆորմի անջատիչը մեզ ասում է, որ մենք կստեղծենք Android հավելված: Սա նշանակում է, որ երբ մենք կառուցենք հավելվածը, Unity-ն կստեղծի APK ֆայլ. Պլատֆորմի անջատիչը նաև Unity-ին ստիպում է վերաներմուծել նախագծի բոլոր ակտիվները: Փոքր նախագծի համար սա երկար չի տևի, բայց հիշեք, որ այս գործողությունը կարող է երկար տևել մեծ նախագծերի համար:

Այժմ մենք պետք է տրամադրենք փաթեթի անվանումը հավելվածի համար:

Նշում:Փաթեթի անունը հավելվածի եզակի նույնացուցիչ է և ձևաչափով գրված է հակառակ DNS ոճով com.CompanyName.ProductName. Հայտը հրապարակելուց հետո Google Playփաթեթի անվանումն այլևս չի կարող փոխվել:

Դա անելու համար անցեք մենյու Խմբագրելև ընտրիր Ծրագրի կարգավորումներ - նվագարկիչ.

Unity-ի աջ կողմում պատուհան կբացվի բազմաթիվ տարբեր կարգավորումներով, ինչպիսիք են հավելվածի տարբերակը, թիրախը և նվազագույն SDK-ն, պատկերակի ընտրությունը և այլն: Այստեղ մեզ անհրաժեշտ է բլոկում Այլ կարգավորումներգտնել Նույնականացումև դաշտում դրեք փաթեթի անվանումը փաթեթի անվանումը. Ցանկության դեպքում կարող եք նաև փոխել այլ կարգավորումներ:

Այժմ մնում է միայն նշել Android SDK-ի և JDK-ի ուղին: Դա անելու համար անցեք մենյու և ընտրեք Խմբագրել-Նախապատվություններ.

Պատուհանում, որը հայտնվում է, անցեք Արտաքին գործիքներև դաշտերում SDKև JDKնշեք համապատասխան ուղիները, այնուհետև փակեք պատուհանը:

Քայլ 6. Հավելվածի ստեղծում և գործարկում

Ժամանակն է ստեղծել ձեր առաջին Unity հավելվածը: Դա անելու համար ընտրեք ընտրացանկից Ֆայլ - Կառուցեք կարգավորումներ. Կբացվի պատուհան, որտեղ դուք պետք է ավելացնեք այն տեսարանը, որը ցանկանում եք հավաքել: Քանի որ մենք արդեն ունենք այս տեսարանը բացված խմբագրիչում, պարզապես սեղմեք Ավելացնել բաց տեսարաններայն համագումարին ավելացնելու համար, այն ավելացնելուց հետո այն կտեսնեք տեսարանների ցանկում:

Մնում է միայն սեղմել Կառուցել, որից հետո Unity-ն կսկսի հավելվածի կառուցումը։ Մինչ այդ ձեզնից կարող է պահանջվել ընտրել թղթապանակ, որտեղ կպահվեն հավաքագրված հավելվածի ֆայլերը, ինչպես նաև APK ֆայլի անունը։

Նշում:վրա այս պահինեթե ունեք ալֆա տարբերակը տեղադրված Android SDK-ում Build-Tools(տարբերակ 28.0.0-rc1), Gradle-ը կառուցելիս սխալ կլինի։ Դա շտկելու համար պարզապես հեռացրեք այս տարբերակը Android SDK-ից:

Արդյունքում, կառուցված APK ֆայլը կհայտնվի ձեր նշած թղթապանակում, որը պատրաստ է տեղադրվելու էմուլյատորում կամ իրական սարքում:

Տեսնենք, թե ինչ կա կառուցված APK-ի ներսում: Դա անելու համար մենք օգտագործում ենք կոմունալը APK անալիզատոր, որը ներառված է Android Studio-ում,

Չսեղմված APK ֆայլի չափն է 21,1 ՄԲ, սեղմված վիճակում 20,9 ՄԲ. Ինչպես տեսնում եք գրաֆիկից, ծավալի մեծ մասը զբաղեցնում են Unity-ի կողմից ավելացված երրորդ կողմի գրադարանները: Հետո ներս ակտիվներտեղակայված են բոլոր ռեսուրսները, որոնք օգտագործվում են հավաքված տեսարանում: Ֆայլ դասեր.dexպարունակում է միայն 89 դասեր և 479 մեթոդները։

Ավելին, եթե նայեք AndroidManifest.xml, հավելվածը բաղկացած է մեկ գործունեությունից։

Եզրակացություն

Այսքանը: Այս հոդվածում մենք սովորեցինք, թե ինչպես տեղադրել և կարգավորել Unity-ն, ինչպես նաև ստեղծել ենք մեր առաջին Android հավելվածը:

Ինչպե՞ս արագ և համեմատաբար հեշտությամբ ստեղծել պարզ խաղ կամ հավելված Android-ի համար: Այս մասին կարդացեք ստորև բերված հոդվածում, որը վերաբերում է Unity3D շարժիչի հետ աշխատելուն:

Դուք խաղում եք համակարգչային խաղեր? Եթե ​​այդպես է, ապա, անկասկած, հաջորդ խաղային բլոկբաստերն անցնելու ընթացքում երբեմն այնպիսի մտքեր եք ունենում, ինչպիսիք են. «Բայց ահա, ես դա սխալ կանեի»: Ցանկանու՞մ եք ինքներդ լինել ծրագրավորող: Հետո առաջարկում եմ մի փոքրիկ, բայց շատ զվարճալի «արկած»;)

Ինչ է շարժիչը և ինչու է այն անհրաժեշտ:

Նախկինում, դեռ առաջին համակարգիչների ժամանակներում, խաղերն ու ծրագրերը ստեղծվում էին այսպես կոչված «հարդքոր» մեթոդով։ Այսինքն, լիարժեք զարգացման համար պահանջվում էր լինել բավականին փորձառու ծրագրավորող, ով լիովին տիրապետում է իր ծրագրավորման լեզվին և կարող է գրել գրեթե ամբողջ խաղը (ներառյալ պիքսելային գրաֆիկան և հատուկ էֆեկտները) պարզ Notepad-ում: Այդպիսի մարդիկ քիչ էին, և նրանց բարձր էին գնահատում (և գնահատում են դեռևս) ...

Այսօր ծրագրավորման թեմա մտնելու շեմը զգալիորեն նվազել է։ Եվ դրան նպաստում է ոչ միայն գրականության և բոլոր տեսակի ուսումնական նյութերի առկայությունը, այլև զարգացման ավելի պարզեցված գործընթացը: Մեր օրերում հազվադեպ կարելի է հանդիպել իրական «հարդքոր» մարդկանց, քանի որ ի հայտ են եկել բավականին հարմար զարգացման միջավայրեր, որոնք կոչվում են «շարժիչներ»։

Շարժիչի էությունն այն է, որ այն թույլ է տալիս ներմուծել բոլոր անհրաժեշտ խաղի օբյեկտները պարզեցված տեսողական ռեժիմով, դասավորել դրանք վիրտուալ բեմում և կարգավորել դրանց բոլոր պարամետրերը: Այսինքն՝ ծրագրավորողի խնդիրը միայն խաղի տրամաբանությունը ճիշտ գրելն է։

Այնուամենայնիվ, աշխատանքի հարմարավետության համար դուք պետք է վճարեք նախագծի չափի մի փոքր աճով (երբեմն նույնիսկ մի քանի անգամ!) համեմատած իր գործընկերոջ հետ, որը գրված է հին «հարդքոր» ձևով: Այս պատճառով է, որ որոշ մշակողներ չեն սիրում շարժիչներ կամ փորձում են գրել իրենցը, որոնցում օգտագործվում են միայն իրենց անհրաժեշտ բաղադրիչները ...

Բայց ես և դու հեռու ենք իսկական ծրագրավորողներից :) Հետևաբար, եկեք ստեղծենք մի պարզ խաղ Android-ի համար՝ հիմնված հանրաճանաչ և հզոր Unity3D շարժիչի վրա։

Ինչպես սկսել Unity3D-ում նախագիծը

Այսպիսով, ինչու մենք որոշեցինք օգտագործել Unity3D:

  • լիարժեք 2D և 3D խաղեր ստեղծելու ունակություն.
  • ցանկացած սարքի համար պատրաստի խաղը կազմելու ունակություն.
  • Շարժիչի կառավարման համեմատաբար հեշտություն;
  • ֆունկցիոնալության լավ ընդարձակելիություն՝ միացնելով պլագինները;
  • խաղի վերջնական հավաքման համեմատաբար փոքր չափը (համեմատած այլ շարժիչների հետ):

Unity3D-ի գլխավոր հաղթաթուղթը, իհարկե, դրա բազմակողմանիությունն ու բազմահարթակությունն է։ Ավարտված խաղ(գուցե մի փոքր ճշգրտումով) Դուք կարող եք տեղափոխել համակարգիչ (Windows, Linux կամ MacOS), Android, PlayStation կամ XBox: Դա անելու համար մենք պետք է ներբեռնենք միայն ինքնին շարժիչը, որն, ի դեպ, «կշռում է» ավելի քան մեկ գիգաբայթ և անհրաժեշտ SDK-ները (եթե մշակումը նախատեսվում է դրա համար. շարժական հարթակներկամ կոնսոլ): Եթե ​​ցանկանում եք Windows-ի համար խաղ պատրաստել, ապա ձեզ ոչինչ պետք չէ ներբեռնել, բայց քանի որ մենք պատրաստվում ենք խաղ պատրաստել Android-ի համար, մեզ անհրաժեշտ կլինի նաև ներբեռնել Android SDK-ն (Software Development Kit): Ես ձեզ խորհուրդ եմ տալիս ներբեռնել SDK-ն ZIP արխիվում՝ դրա հետ աշխատելու ավելի հարմարավետության համար:

Երբ ամեն ինչ ներբեռնվի, դուք կարող եք ապափաթեթավորել Android SDK-ի ցանկացած թղթապանակ, որը հարմար է ձեզ համար, այնուհետև շարունակեք տեղադրել Unity3D-ը: Այն տեղադրված է Windows-ի ցանկացած սովորական ծրագրի նման, ուստի տեղադրման հետ կապված խնդիրներ չպետք է լինեն: Տեղադրվելուց հետո շարժիչը կգործարկվի, և մենք նախ պետք է ստեղծենք նոր նախագիծ.

Դա անելու համար մեզ անհրաժեշտ կլինի փակել բոլոր ողջույնի և ներածական պատուհանները, այնուհետև «Ֆայլ» ցանկից ընտրել «Նոր նախագիծ»: Բացվող պատուհանում (տե՛ս վերևի սքրինշոթը), մեզ կառաջարկվի նշել նախագծի պահպանման թղթապանակը (նրա անունը կլինի նույնը, ինչ նախագծի անունը), ներմուծել որոշ ստանդարտ գործառույթների հավաքածուներ (դրանք մեզ պետք չեն) և նշել. գործառնական ռեժիմը. Ընտրեք 2D-ը որպես ռեժիմ և սեղմեք «Ստեղծել» կոճակը: Սա ավարտում է աշխատանքի նախապատրաստական ​​մասը :)

Շարժիչի միջերեսը և նախագծի հիերարխիան

Նախագիծը ստեղծելուց հետո այն կբեռնվի Unity3D աշխատանքային տարածքում.

Այս աշխատանքային տարածքն ինքնին ունի մոդուլային կառուցվածք և բաղկացած է մի քանի ներդիր պատուհաններից, որոնք կարող են տեղաշարժվել ըստ ցանկության: Ես այն կարգավորել եմ այսպես (ձախից աջ և վերևից ներքև).

  1. Հիերարխիայի պատուհան - ցուցադրում է տեսարանի վրա ակտիվ և ոչ ակտիվ օբյեկտների հիերարխիկ դիրքը: Լռելյայնորեն, միակ օբյեկտը անմիջապես ցանկում հիմնական տեսախցիկն է:
  2. Տեսարանի պատուհան - ցուցադրում է խաղի ամբողջ տեսարանը և դրա վրա գտնվող առարկաները (ներառյալ տեսախցիկները, ձայները, հյուսվածքները և այլն):
  3. Տեսուչի պատուհան - ցուցադրում է հիերարխիայում կամ բեմում ընտրված օբյեկտի բոլոր հատկությունները և թույլ է տալիս խմբագրել, լրացնել կամ ջնջել դրանք:
  4. Խաղի պատուհան - ցուցադրում է խաղի աշխարհը, որը տեսանելի է տեսախցիկին և թույլ է տալիս ընտրել վիրտուալ խաղի թեստային պատուհանի չափը պիքսելներով: Նաև թույլ է տալիս ակտիվացնել խաղի պատուհանի ընդլայնումը լրիվ չափով (Maximize on Play) և միացնել/անջատել տարբեր տեղեկատվության ցուցադրումը մշակողի համար:
  5. Ծրագրի և կոնսոլի պատուհաններ: Ծրագրի պատուհանն օգտագործվում է ծրագրի ռեսուրսների միջով նավարկելու համար՝ վերբեռնված պատկերներ, ձայներ, մոդելներ և այլն: Նաև այս պատուհանի միջոցով (համատեքստային մենյու) կարող եք ստեղծել տարբեր տեսակի և սցենարների նոր դատարկ խաղային օբյեկտներ: Վահանակով պատուհանը օգտագործվում է սխալ հաղորդագրություններ (կարմիր), նախազգուշացումներ (դեղին) և ձեր կողմից պահանջվող տարբեր վրիպազերծման տեղեկություններ ցուցադրելու համար (մոխրագույն):
  6. Assets Label պատուհանը տեսուչի պատուհանի ստորին հատվածն է, որը ցուցադրում է Ծրագրի պատուհանում ընտրված օբյեկտի կամ ֆայլի նախադիտումը:

Բացի վերը նշված բոլորից, ուշադրություն դարձրեք վերին կենտրոնում գտնվող երեք կոճակներին: Նրանք թույլ են տալիս սկսել ձեր նախագիծը, դադարեցնել այն (երբեմն օգտակար է վրիպազերծման ժամանակ, որպեսզի տեսնեք, թե ինչ է արվում հիերարխիայում, օրինակ) և, համապատասխանաբար, անջատեք այն:

Մենք կստեղծենք երաժշտական ​​գործիքի սիմուլյատոր՝ հնդկական ժողովրդական թմբուկներ, որը կոչվում է «tabla», հետևաբար, սկսելու համար նախագծում կստեղծենք երկու դատարկ թղթապանակ, որոնցում կպահվեն ձայները և նկարները։ Դուք կարող եք ստեղծել նոր թղթապանակ՝ զանգահարելով Project Navigator պատուհանի համատեքստային մենյու և ընտրելով «Թղթապանակ» տարրը «Ստեղծել» ցանկից:

Այստեղ արժե մի քանի խոսք ասել, թե ինչպես պետք է անվանել այս թղթապանակները։ Պարզ խաղի համար, ինչպես մեր սիմուլյատորը, սկզբունքորեն, թղթապանակները կարող են «անվանվել», ինչպես ցանկանում եք, այնուամենայնիվ, կան առնվազն երկու անուն, որոնք ավելի լավ է չօգտագործել, քանի որ դրանք վերապահված են շարժիչով: Սրանք Resources և Plugins անուններն են: Խոշոր նախագծերում Resources թղթապանակը ստեղծվում է անմիջապես, և բոլոր խաղի «պահեստամասերը» (նկարներ, ձայներ, մոդելներ, հյուսվածքներ և նախապատկերներ) արդեն պահվում են դրանում (տեսակավորված ըստ ենթաթղթապանակների): Plugins-ում, ինչպես ենթադրում է անվանումը, պահվում են երրորդ կողմի գործառույթների բոլոր լրացուցիչ հավաքածուները (այսպես կոչված «ակտիվներ» (ակտիվներ)), որոնցից մի քանիսը կան Asset Store-ում՝ Unity3D-ի ընդլայնումների պահեստ:

Ֆայլերի ներմուծում և խաղի օբյեկտների ստեղծում

Նախքան նոր խաղային նախագիծ ստեղծելը, խորհուրդ է տրվում նախապես պատրաստել դրա շահագործման համար անհրաժեշտ բոլոր ֆայլերը։ Մեր դեպքում այս ֆայլերը նկարներ և ձայներ են: Դրանք նախագիծ ներմուծելու ամենահեշտ ձևն այն է, որ դրանք պարզապես քաշել և թողնել ցանկալի թղթապանակ: Սկսենք նկարներից...

Այն բանից հետո, երբ պատկերները հայտնվում են մեր Պատկերների պանակում, դրանք պետք է մի փոքր շտկվեն.

Փաստն այն է, որ լռելյայնորեն Unity3D-ը սեղմում է նախագծին ավելացված բոլոր պատկերները որակի կորստով: Եթե ​​մեզ նման կորուստ պետք չէ (հատկապես ճիշտ է HD գրաֆիկայով խաղերի համար), ապա մենք պետք է ընտրենք յուրաքանչյուր պատկեր և Inspector պատուհանում փոխենք «Format» պարամետրի արժեքը «Compressed»-ից «Truecolor»-ի «Default»-ում: «ներդիր. Հնարավոր է, որ անհրաժեշտ լինի փոխել «Max Size» պարամետրը, եթե այն փոքր է իրական պատկերի լայնությունից (կանխադրվածը 1024 պիքսել է): Բոլոր փոփոխություններից հետո դուք պետք է հիշեք սեղմել «Դիմել» կոճակը՝ դրանք կիրառելու համար: Անհրաժեշտության դեպքում մենք կատարում ենք նմանատիպ գործողություններ մնացած բոլոր պատկերների համար:

Հիմա եկեք ստեղծենք խաղի առարկաներ մեր նկարներից: Դա անելու համար պարզապես քաշեք ցանկալի պատկերը Հիերարխիայի պատուհանում: Նկարը կամ 3D մոդելը ավտոմատ կերպով կվերածվի Խաղի օբյեկտի և կցուցադրվի տեսախցիկի դիմաց գտնվող մեկնարկային կոորդինատային կետում:

Առաջին հերթին մենք ավելացրել ենք ֆոնային պատկեր, որը պետք է ցուցադրվի ամբողջ էկրանով։ Դուք կարող եք ստուգել, ​​թե արդյոք դա այդպես է, ընտրելով տեսախցիկը հիերարխիայի պատուհանում և տեսնելով, թե ինչպես է ցուցադրվում դրա շրջանակը: Վերևի սքրինշոթում դուք կարող եք տեսնել, որ մեր ֆոնի մի մասը մնում է տեսախցիկի տեսադաշտից դուրս, ուստի մենք պետք է կարգավորենք այս տեսքի չափը՝ քաշելով շրջանակը անմիջապես բեմի վրա կամ խմբագրելով «Չափ» պարամետրը Inspector պատուհանում: Մեր դեպքում մենք պետք է փոխեինք լռելյայն արժեքը (5) 5.4-ի:

Վերջ, տեսախցիկին չենք դիպչում, այլ ավելացնում ու կարգավորում ենք մնացած նկարները։ Ավելացնելիս տեսնում ենք, որ դրանցից մի քանիսը չափազանց մեծ են մեր խաղի համար։ Դուք կարող եք դրանք կրճատել կամ ֆիզիկապես գրաֆիկական խմբագրիչում, կամ շարժիչի միջոցով: Փորձենք վերջին մեթոդը. Դա անելու համար ընտրեք պատկերը Հիերարխիայի պատուհանում, իսկ Inspector պատուհանում փոխեք «Scale» արժեքները X և Y կոորդինատների համար 1-ից մինչև 0.5 (այսինքն, կրճատեք կիսով չափ): Նույն տեղում, համընկնումներից խուսափելու համար, ցանկալի է բոլոր խաղի օբյեկտներին (բացառությամբ ֆոնի) վերագրել շերտերի ոչ զրոյական կարգ (Order in Layer).

Խաղային առարկաները նկարներից պատրաստելու վերջին քայլը կլինի դրանց վրա «կախված» կոլայդերները: Unity3D-ում կոլայդերները օգտագործվում են որպես առարկաների միջև փոխազդեցության դետեկտորներ: Այսինքն, փաստորեն, մեր նկարի վրա դրված է վիրտուալ պատյան, որը կարող է հպումներ գրանցել դրան։

Օբյեկտին կոլայդեր ավելացնելու համար ընտրեք այն Հիերարխիայի պատուհանում, այնուհետև կտտացրեք «Ավելացնել բաղադրիչ» կոճակը Inspector պատուհանում: Հայտնվող բաղադրիչների ցանկում մենք փնտրում ենք Physics 2D (սովորական 3D ֆիզիկան մեր ռեժիմում չի աշխատի) և բոլոր տարբերակներից մեզ ամենահարմարը «Circle Collider 2D»-ն է։ Մենք ընտրում ենք նրան: Մեր օբյեկտի շուրջը կհայտնվի կանաչ հարված, որը ցույց է տալիս բախողի սահմանները: Մնում է միայն ստուգել «Is Trigger» վանդակը, որպեսզի մեր բախիչը գրանցի միայն սեղմումները և այլևս չշփվի շրջակա խաղի տարածության հետ.

Նմանատիպ գործողությունները կրկնվում են մնացած բոլոր օբյեկտների համար: Միայն մեր ֆոնը կտարբերվի այլ օբյեկտներից: Դրա համար մենք կկիրառենք Box Collider 2D և կդնենք Z-ի դիրքը զրոյից մեծ՝ կոլայդերը և ֆոնը հետին պլան մղելու համար (դա մեզ ավելի ուշ պետք կգա):

Ձայնի հետ աշխատելը

Unity 3D-ում ձայնի դեպքում, առաջին հայացքից, ամեն ինչ ինչ-որ չափով շփոթեցնող է: Բայց, եկեք փորձենք պարզել դա ըստ հերթականության :)

Նախևառաջ, մենք պետք է քաշենք բոլոր հնչյունները Sounds թղթապանակ և դրանք նույնպես մի փոքր կսմթենք.

Եթե ​​ձեր բոլոր հնչյունների ձայնի մակարդակը ի սկզբանե ճշգրտված է, ապա ձեզ հարկավոր է ընդամենը անջատել 3D ձայնի մշակումը: Եռաչափ խաղերում այս մշակումն անհրաժեշտ է ձայնի աղբյուրի մոտենալը մոդելավորելու համար, երբ տեսախցիկը մոտենում է դրան: Բայց 2D-ում մեզ սա պետք չէ, ուստի մենք հերթով ընտրում ենք յուրաքանչյուր ձայն և հանում «3D Sound»-ի նշումը:

Այժմ մենք կարող ենք սկսել ձայներ ավելացնել խաղի օբյեկտներին: Դա անելու համար մենք պետք է հերթով ընտրենք յուրաքանչյուր կոճակ և դրան ավելացնենք նոր «Աուդիո աղբյուր» բաղադրիչ «Աուդիո» բաժնից: Երբ բաղադրիչն ավելացվի, ընտրեք համապատասխան «Աուդիո հոլովակ» կոճակը և հանեք «Play On Awake» վանդակը, որն ակտիվ է լռելյայնորեն (նվագարկեք, երբ այն հայտնվի):

Երբ բոլոր հնչյունները կցված են ճիշտ կոճակներին, ժամանակն է զվարճալի մասի՝ սցենարի...

Առաջին սցենար

Նախքան մեր առաջին սցենարի վերլուծությունը սկսելը, հավանաբար արժե մի քանի խոսք ասել բուն Unity 3D-ում սկրիպտավորման համակարգի մասին:

Unity-ն թույլ է տալիս կոդ գրել միանգամից երեք լեզվով՝ JavaScript (ավելի ճիշտ՝ UnityScript-ի դրա մի փոքր փոփոխված տարբերակը), C # և Boo: Մի շարք գրքերում և ուղեցույցներում կարող եք գտնել այն կարծիքը, որ սկսնակների համար Unity-ում սկրիպտավորումն ավելի հեշտ է տիրապետել JavaScript-ի օրինակով: Այնուամենայնիվ, այս լեզուն այնքան էլ հարմար չէ, որքան մյուսները, և ապագայում, ամենայն հավանականությամբ, ստիպված կլինեք նորից սովորել: Հետևաբար, ավելի լավ է անմիջապես սկսել՝ սովորելով C # (Boo-ն նույնպես լավ է, բայց դրա վրա ուսուցողական նյութերը քիչ են):

Այժմ այն ​​մասին, թե որտեղ պետք է գրել կոդը: Unity 3D-ում կոդերի լռելյայն խմբագրիչը MonoDevelop IDE-ն է: Այս զարգացման միջավայրի առավելությունն այն է, որ այն ունի ստանդարտ մեթոդներ, դասեր և գործառույթներ արագ մուտքագրելու հուշումներ, ինչպես նաև շարահյուսության ստուգման համակարգ: Այնուամենայնիվ, ինձ համար թերությունը մեծածավալությունն ու ռեսուրսների բարձր ինտենսիվությունն էր: Բարեբախտաբար, Unity-ի կարգավորումներում դուք կարող եք ցանկացած բան սահմանել որպես տեքստային խմբագրիչ, այնպես որ ես ինձ համար «կախեցի» թեթև և ֆունկցիոնալ Notepad ++-ը (գրեթե բոլոր օրինակները կցուցադրվեն դրանում):

Եվ վերջինը. Բնականաբար, առանց շարժիչի բոլոր խճճվածությունները յուրացնելու տեղեկատու նյութերի, դուք հեռու չեք գնա, ուստի ահա մի քանի խելամիտ ինտերնետային ռեսուրսների ցուցակ Unity 3D թեմայի վերաբերյալ.

  • http://docs.unity3d.com/ru/current/Manual/UnityManualRestructured.html - շարժիչի պաշտոնական ձեռնարկ ռուսերեն մասնակի թարգմանությամբ (հայտնվել է վերջերս և երբեմն անկայուն է);
  • http://docs.unity3d.com/ru/current/ScriptReference/index.html - սկրիպտավորման պաշտոնական ուղեցույց անգլերեն լեզվով;
  • http://unity3d.ru/distribution/index.php - Ռուսական ֆորում Unity 3D մշակողների համար;
  • http://habrahabr.ru/post/141362/ - դասերի շարք Habrahabr-ում եռաչափ խաղեր ստեղծելու վերաբերյալ;
  • http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - Microsoft-ի պաշտոնական C# հղումը ռուսերեն լեզվով:

Դե, որպեսզի այն երկար չձգձգվի, առաջարկում եմ անմիջապես ստեղծել առաջին սցենարը։ Սկրիպտների տակ, եթե դրանք շատ են, ավելի լավ է հատկացնել առանձին թղթապանակ, բայց մեր խաղը պարզ կլինի, այնպես որ մենք կարող ենք ստեղծել սցենար անմիջապես նախագծի արմատային թղթապանակում: Դա անելու համար Ծրագրի պատուհանում զանգահարեք համատեքստային մենյու, ընտրեք Ստեղծել ցանկը և սեղմեք «C# Script»: Անվանենք մեր նոր սցենարը, օրինակ, Sounds և բացենք այն կրկնակի սեղմումով։ Հեռացնելով «Թարմացնել» և «Սկսել» ստանդարտ մեթոդները, այնուհետև, գրանցելով անհրաժեշտները, մենք ստանում ենք հետևյալ սցենարը.

Եթե ​​դուք չեք վերակազմավորել խմբագրիչը, ապա մեր սցենարը կբացվի MonoDevelop-ում: Եկեք նայենք նրա կառուցվածքին...

Իրականում, յուրաքանչյուր C# սցենար բաղկացած է երեք հիմնական մասից.

  1. Հենց վերևում նշված են գրադարանները, որոնք պետք է միացվեն, որպեսզի սկրիպտը աշխատի (օրինակ՝ «Using Unity.Engine»-ը միացնում է բուն շարժիչի աշխատանքը, իսկ «օգտագործելով System.Collections»-ը՝ թվեր պարունակող գրադարան։ ներկառուցված դասեր, որպեսզի սցենարը աշխատի տարբեր համակարգերում):
  2. Դասի և փոփոխականի հայտարարագիր: C#-ում որպես այդպիսին սկրիպտ հասկացություն չկա։ Փոխարենը օգտագործվում է «դաս» հասկացությունը, որը ներառում է մի շարք մեթոդներ և գործառույթներ։ Չնայած, փաստորեն, Unity 3D-ի համատեքստում սա գրեթե նույն բանն է :) Հիմնական բանը, որ պետք է հիշել, այն է, որ դասի անունը պետք է համապատասխանի այն անվանը, որը մենք տվել ենք սցենարը: C#-ում փոփոխականների առանձնահատկությունն այն է, որ դրանք պետք է (բացառությամբ ժամանակավորների, որոնք հայտարարված են հենց սկրիպտում) տպագրվեն։ Գործնականում դա նշանակում է, որ փոփոխականի համար պետք է նշվեն մուտքի մակարդակը (մասնավոր կամ հանրային) և տեսակը (int, float, bool կամ, ինչպես մենք ունենք սկրիպտում, AudioClip): Միևնույն ժամանակ, ցանկացած փոփոխականի անուն կարող է լինել. տրված է Կամ դուք կարող եք անմիջապես տալ դրան արժեք վերագրել:
  3. Մեթոդների և գործառույթների մի շարք: C#-ում մեթոդը գրեթե ցանկացած գործառույթ է, որը կատարում է որոշակի գործողություններ: Սկզբունքորեն, Unity 3D-ի գրականության մեջ դրանք կոչվում են ֆունկցիաներ, բայց եթե մենք խոսում ենք C #-ի մասին՝ որպես առանձին ծրագրավորման լեզու, ապա սրանք, ի վերջո, մեթոդներ են :): Unity-ում մաքուր գործառույթներն են, օրինակ, ստանդարտ գործառույթներ ձայնի ելքի, GUI տարրեր նկարելու և այլն, որոնք օգտագործվում են մեթոդների ներսում:

Հիմա իմանալով սցենարի կառուցվածքը՝ հեշտ է հասկանալ դրա իմաստը, որը հանգում է հետևյալին... Sounds դասում (script) հայտարարում ենք AudioClip տեսակի 9 փոփոխական՝ մեզ անհրաժեշտ անուններով, որոնք հարմարության համար են։ դրանք առանձնացնելով. Մենք դրանք դարձնում ենք պարտադիր հրապարակային (մասնավորները խմբագրիչում չեն ցուցադրվի, և մեզ անհրաժեշտ կլինի խմբագրի միջոցով ձայներ «կախել» դրանց վրա): Եվ այնուհետև սցենարի մարմնում մենք օգտագործում ենք «void OnMouseDown ()» ստանդարտ մեթոդը: Նախկինում այն ​​պատասխանատու էր միայն մկնիկի սեղմման մշակման համար, սակայն նոր տարբերակներում այն ​​մեկնաբանվում է նաև որպես հպում սենսորային էկրանին։ Նրանում գրում ենք այն պայմանները, որոնցով ստուգում ենք սեղմված կոլայդերների անունները և, եթե հայտնաբերում ենք դրանցից որևէ մեկի սեղմումը, թողարկում ենք համապատասխան ձայնը (օգտագործում ենք ստանդարտ audio.PlayOneShot(); ֆունկցիան։

Կոդ գրելիս զգույշ եղեք ներառել բացման և փակման բոլոր փակագծերը, հակառակ դեպքում դուք անընդհատ սխալի մասին հաղորդումներ կստանաք Console-ում և ընդհանրապես չեք կարողանա գործարկել ձեր նախագիծը: Ուշադրություն դարձրեք նաև մեթոդների և գործառույթների անվանումներում մեծատառերի օգտագործմանը: Նրանք նաև հաճախ սխալների պատճառ են հանդիսանում։ Եվ, իհարկե, դիտարկեք բոլոր նշանները (կետ, երկու կետ և փակագծեր), մի խոսքով, լեզվի շարահյուսությունը: Սկզբում դժվար կլինի, բայց ժամանակի ընթացքում կսկսես զրոյից գրել առանց սխալների։

Երբ սկրիպտը պատրաստ է, ընտրեք այն և Inspector պատուհանում յուրաքանչյուր փոփոխականին տարբեր ձայն հատկացրեք: Այժմ մենք պարզապես պետք է կիրառենք մեր սցենարը տեսարանի օբյեկտների վրա: Դա անելու ամենահեշտ ձևը կրկին սցենարը քաշելն է Հիերարխիայի ցանկի ցանկալի խաղի օբյեկտի վրա.

Եթե ​​սցենարը ճիշտ է քաշվել, ապա այն պետք է հայտնվի Inspector պատուհանում այն ​​օբյեկտի կողքին, որի վրա մենք այն քաշել ենք։ Համապատասխանաբար, մենք քաշում ենք սցենարը բոլոր այն օբյեկտների վրա, որոնք պետք է հնչեն խաղի մեջ և կարող ենք փորձել այն գործարկել։ Երբ սեղմում եք մեր խաղի կոճակները, այժմ, վերջապես, կհնչի նշված ձայնը:

Ներածություն GUI-ին

Սկզբունքորեն, խաղը մեզ մոտ արդեն գործում է, բայց ինչ-որ կերպ չափազանց «ճաղատ» է։ Դրանում ինչ-որ բան պակասում է ... Կամ, գոնե, մակագրություն անունով, որը մեր առջև է: Այլ կերպ ասած, դուք պետք է ներդրեք ինչ-որ հասկանալի ինտերֆեյս:

Իրականում, GUI-ն անգլերենի հապավումն է: «Գրաֆիկական ինտերֆեյս», այսինքն՝ գրաֆիկական ինտերֆեյս։ Ավանդաբար, այն ներառում է այնպիսի բաղադրիչներ, ինչպիսիք են.

  • կոճակներ;
  • պատուհան;
  • տեքստային տարածքներ;
  • վանդակներ և/կամ ռադիո կոճակներ;
  • սահիկներ (ոլորման գծեր) և այլն:

Unity 3D-ում այս ամենը (և նույնիսկ դրանից ավելին) լիովին առկա է: Հիմնական բանը սովորելն է, թե ինչպես օգտագործել այն: Եկեք նայենք, թե ինչպես կարող է Unity-ի GUI-ն ստեղծել պարզ վերնագիր:

Դա անելու համար ստեղծեք նոր սկրիպտ, որը կոչվում է Interface և փոփոխեք այն հետևյալ կերպ.

Ուշադիր դիտարկեք սքրինշոթի սցենարը: Այստեղ մենք գրում ենք միայն մեկ հանրային փոփոխական GUIStyle տեսակի, որը մեզ համար նորություն է։ Այս տեսակը թույլ է տալիս տեսողականորեն փոխել այն տարրերի տեսքը, որոնց վերագրված է այս ոճը: Ոճերը օգտակար են, երբ կան նույն տեսակի ինտերֆեյսի բազմաթիվ տարրեր (օրինակ՝ կոճակներ), բայց դրանք պետք է այլ տեսք ունենան։

Այնուհետև մենք ստեղծում ենք կոճակ («GUI.Button»), որն ունի հետևյալ շարահյուսությունը՝ պայման - 4 կոորդինատ (հորիզոնական նահանջ ձախ եզրից, ուղղահայաց նահանջ վերևի եզրից, լայնություն, բարձրություն) - տեսանելի տեքստ չակերտներում և հետագա , ըստ ցանկության, ոճի նշում։ Կոճակի պայմանի ներսում գրված են անհրաժեշտ գործառույթները։ Մեր դեպքում մենք գրանցեցինք անցումը ծրագրավորողների կայք («Application.OpenURL(«»);»):

GUI-ի սկրիպտները կարող են աշխատել ցանկացած խաղի օբյեկտից, բայց սովորաբար նրանց խորհուրդ է տրվում «կախել» դրանք տեսախցիկի վրա, ինչը մենք կանենք՝ սկրիպտը քաշելով հիմնական տեսախցիկի օբյեկտի վրա: Այժմ, եթե մենք ընտրենք այն Hierarchy պատուհանում, ապա Inspector պատուհանում մենք կկարողանանք տեսնել մեր ոճի հանրային փոփոխականը, ընդլայնելով այն, մենք լիարժեք մուտք կունենանք այս ոճի կարգավորումներին:

Մենք կարող ենք ցանկացած իրավիճակում նշել ֆոնի տեքստի գույնը և հյուսվածքը (կոճակի համար անհրաժեշտ է գրանցել դրա երեք տարբերակները (Normal - նորմալ դիտում, Hover - սավառնելիս և Active - սեղմումով), սահմանել padding և կարգավորել տառատեսակը: Լռելյայնորեն, Unity 3D-ում միակ հասանելի տառատեսակը Arial-ն է, այնուամենայնիվ, դուք կարող եք ձեռքով բեռնել ցանկացած այլ տառատեսակ նախագծում և կիրառել այն «Font» դաշտում՝ սահմանելով բոլոր հարակից պարամետրերը:

Հետաքրքիրն ու միևնույն ժամանակ ոչ այնքան հարմարն այն է, որ GUI-ի տարրերը չեն ցուցադրվում բեմում, քանի դեռ չենք սկսել նախագիծը, ուստի յուրաքանչյուր տարրի պարամետրերի կարգավորումը կարող է շատ ժամանակ խլել: Եկեք գործարկենք նախագիծը և տեսնենք, թե ինչ տեսք կունենա վերևում ստեղծված մեր կոճակը.

Ինտերֆեյսի փոփոխություն ըստ պայմանի և ստատիկ փոփոխականների

Մենք արդեն շատ բան ենք արել, բայց միշտ էլ կատարելագործվելու տեղ կա :) Ուստի որպես վերջին օրինակ առաջարկում եմ ստեղծել օգնության պատուհան, որով նորմալ մշակողները սովորաբար մատակարարում են իրենց խաղերն ու հավելվածները։ Դա անելու համար նման կոճակի համար հարցականի տեսքով նկար ավելացրեք պատկերներով թղթապանակում և դրանից խաղային օբյեկտ պատրաստեք։ Եկեք դրա վրա կախենք կոլայդեր և գրենք սկրիպտ անունով, օրինակ՝ «Օգնիր» հետևյալ բովանդակությամբ.

Այս սցենարում մենք ունենք երկու փոփոխական: Առաջին փոփոխականը սահմանում է մաշկը, որը կօգտագործվի այս դասում նկարագրված բոլոր ինտերֆեյսի տարրերի համար: Ի տարբերություն ոճերի, որոնք մենք քննարկեցինք վերևում, երեսվածքները թույլ են տալիս փոխել ոչ միայն առանձին տարրի տեսքը, որին դրանք վերագրված են, այլև որոշակի տեսակի բոլոր տարրերը միանգամից: Բացի այդ, ի տարբերություն ոճերի, երեսվածքները չեն վերագրվում տարրերին, այլ հայտարարվում են անմիջապես ամբողջ մեթոդի համար և աշխատում են այնքան ժամանակ, մինչև չհայտարարվի մեկ այլ երեսպատում: Պետք է նաև հիշել, որ երեսվածքները գոյություն ունեն ոչ միայն որպես փոփոխականներ, այլև որպես անհատական ​​ֆայլեր. Հետեւաբար, նախքան սկին հայտարարելը, դուք պետք է անմիջապես ստեղծեք այն «Նախագիծ» պատուհանում՝ համատեքստի ընտրացանկից՝ «Ստեղծել» - «GUI Skin»:

Երկրորդ փոփոխականը, որը մենք ունենք, տրամաբանական է (կամ այլ կերպ՝ բուլյան): Այն կարող է ունենալ միայն երկու արժեք՝ «true» (true) կամ «false» (false): Իր երկուական բնույթի շնորհիվ նման փոփոխականը կատարյալ է բոլոր տեսակի անջատիչների իրականացման համար: Մեր դեպքում նա պատասխանատու կլինի մեր խաղը նկարագրող տեքստի ցուցադրման համար։

Սակայն, եթե ուշադիր նայեք, կնկատեք, որ վերջին փոփոխականն ունի մեկ հրաշալի պարամետր՝ «ստատիկ»։ Այս պարամետրը փոփոխականներին ավելացնելը թույլ է տալիս դրանք ստատիկ դարձնել և մուտք գործել այլ սկրիպտներից:

Բայց վերադառնանք մնացած ծածկագրին: Այստեղ մեզ արդեն ծանոթ «void OnMouseDown()» մեթոդը կծառայի որպես «isVisible» փոփոխականի փոխարկիչ՝ օգտագործելով պարզ պայման: Այնուամենայնիվ, պայմանից հետո մեկ այլ գործառույթ կա. Այս ֆունկցիան («Debug.Log();») օգտագործվում է Վահանակին «ուղու վրա» դուրս բերելու մեզ անհրաժեշտ փոփոխականների արժեքները (մենք դրանք մուտքագրում ենք առանց չակերտների փակագծերում): Ինչպես տեսնում եք, ֆունկցիայի ներսում կարող եք համատեղել և՛ անփոփոխ տեքստը (գրված է չակերտներով), և՛ փոփոխականները (առանց չակերտների): Հիմնական բանը այն է, որ բոլոր տվյալների միջև պետք է լինի «+» նշան:

Հետագայում սցենարի տեքստում մենք ունենք միջերեսը նկարելու մեթոդ («void OnGUI()()»), որի ներսում մենք տեսնում ենք նոր մաշկի («GUI.skin = HelpSkin;») և նորի հայտարարությունը: GUI.Box տեսակի միջերեսի տարր: Ի տարբերություն կոճակի, տուփը ոչ ակտիվ տարր է և սովորաբար ծառայում է տարբեր տեքստային կամ գրաֆիկական տվյալներ ցուցադրելու համար:

Ուշադրություն դարձրեք, թե ինչպես ենք դրել տուփի դիրքը: Այստեղ բոլոր արժեքները նշված չեն ուղղակիորեն, այլ մաթեմատիկական արտահայտությունների օգնությամբ, որը, ըստ էության, վեբ մշակման մեջ «հեղուկ դասավորության» անալոգն է։ Խնդիրն այն է, որ էկրանի տարբեր լուծաչափերով GUI տարրերի ճշգրիտ չափերը նշելիս դրանք չեն հարմարվի և կարող են լինել կամ չափազանց փոքր կամ ընդհակառակը, մեծ: Շարժիչի հաջորդ տարբերակում մշակողները խոստանում են GUI-ը դարձնել հարմարվողական, բայց առայժմ մենք պետք է այլասերվենք :(

Հաջողության ճանապարհին վերջին քայլը կլինի մեր մաշկի հարմարեցումը: Մենք նշում ենք skin ֆայլը script փոփոխականում, այնուհետև ընտրում ենք այս ֆայլը նախագծի պատուհանում: Ինչպես մյուս ֆայլերի դեպքում, մաշկի կարգավորումները կցուցադրվեն Inspector պատուհանում: Այստեղ մենք փնտրում ենք այն տարրը, որը ենթակա է փոփոխության (մեր դեպքում՝ Box), բացեք այն և կարգավորեք այն նույն կերպ, ինչպես վերը քննարկված ոճը.

Տեսնելու համար, թե արդյոք մեր սցենարը ճիշտ է աշխատում, եկեք գործարկենք նախագիծը և փորձենք սեղմել օգնության կոճակը.

Այժմ ամեն ինչ աշխատում է, բայց միշտ չէ, որ հարմար է սեղմել օգնության կոճակը՝ նկարագրությունը ետ թաքցնելու համար: Ավելի ընդունված է ցանկացած ծանուցում տեղադրել որևէ մեկի մեջ ազատ տեղքան կոճակներին ուղղված նպատակը: Եվ հենց այստեղ է պետք ուղղակի օգտագործել այն փաստը, որ մենք «isVisible» փոփոխականը դարձրինք ստատիկ, ինչպես նաև ֆոնային պատկերի վրա կախված կոլայդերը...

Եկեք վերադառնանք մեր առաջին սցենարին («Հնչյուններ»), որը հետևում է կոճակի սեղմումներին՝ հնչյուններ նվագարկելու համար: Մեզ համար բավական կլինի միայն մեկ տող գրել դրա մեջ (ավելի ճիշտ՝ «void OnMouseDown ()» մեթոդի ներսում.

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

Այս տողով մենք պայման ենք դնում. եթե սեղմված կոլայդերի անունը չի համընկնում օգնության կոճակի անվան հետ, ապա «Օգնություն» սկրիպտի «isVisible» փոփոխականը հավասար կլինի «false»: Միայն անհրաժեշտ է, որ «isVisible» փոփոխականը անպայման ունենա «static» հետգրություն, հակառակ դեպքում մենք սխալ կստանանք։

Այժմ, գործարկման ժամանակ, մենք կտեսնենք, որ մեր օգնության պատուհանը փակ է ոչ միայն վերին աջ անկյունում գտնվող կոճակի վրա սեղմելիս, այլև էկրանի ցանկացած ազատ հատվածին հպվելիս: Միակ բանը, որ կարելի է կատարելագործել, այն է, որ պատուհանը թաքնվի, երբ սեղմում ես դրա վրա... Սա կլինի քո «տնային աշխատանքը»;) Ես կարող եմ միայն ասել, որ GUI-ի տուփը նորից պետք է փոխվի նույնատիպ ձևավորված կոճակի։ , կարգավորվող մաշկի հետ և նշանակելով գործառույթ, որը փոխում է «isVisible» փոփոխականը: Ամեն ինչ, լռիր :)

Խաղը կազմելը և նախագիծը պահպանելը

Ի վերջո, ամեն ինչ աշխատում է մեզ համար: Սա նշանակում է, որ ժամանակն է փրկել մեր խաղը և փորձարկել այն իրական սարքի վրա: Եվ դրա համար այն պետք է կազմվի գործարկվող ֆայլի մեջ (Windows-ի համար, օրինակ, EXE-ում, իսկ Android-ի համար՝ APK-ում):

Եթե ​​ցանկանում եք համակարգչի համար խաղ կազմել, ապա պետք չէ նախնական կարգավորումներ կատարել: Այնուամենայնիվ, Android-ի համար նախ պետք է միացնել Android SDK-ն, որը մենք ներբեռնել ենք հենց սկզբում: Դա արվում է բավականին պարզ՝ անցեք «Խմբագրել» մենյու, զանգահարեք «Նախապատվություններ» կետը և բացվող պատուհանում անցեք «Արտաքին գործիքներ» ներդիրին: Այստեղ մենք փնտրում ենք «Android SDK Location» տողը և դրանում նշում ենք SDK-ով չփաթեթավորված արխիվի ուղին (տես ստորև ներկայացված սքրինշոթը): Ի դեպ, այստեղ դուք կարող եք նաև փոխել լռելյայն գործող հրեշավոր MonoDevelop տեքստային խմբագրիչը ձեր նախընտրածի :)

Եվ հիմա եկել է ճշմարտության պահը: Գնացեք «Ֆայլ» ընտրացանկ և այնտեղ փնտրեք «Կառուցման կարգավորումներ» կետը: Բացվող պատուհանում մեզ անհրաժեշտ կլինի անհապաղ ավելացնել տեսարաններ հավաքման համար: Եթե ​​կա միայն մեկ տեսարան (ինչպես մեր նախագծում), ապա բավական կլինի սեղմել «Ավելացնել ընթացիկ» կոճակը։ Եթե ​​դրանք մի քանիսն են, ապա ձեզ հարկավոր է բացել դրանցից յուրաքանչյուրը և նույն կերպ ավելացնել տեսարանների ցանկին, այնուհետև, քաշելով և թողնելով, կարգավորել դրանց ցանկալի հերթականությունը.

Հաջորդ քայլը պետք է ընտրել կառուցման հարթակը (մենք նախատեսում ենք խաղ Android-ի համար, ինչը նշանակում է, որ մենք ընտրում ենք այն) և սեղմեք «Player Settings» կոճակը ստորև: Inspector պատուհանը կբացի մի շարք կարգավորումներ, որոնցից մի քանիսը պարտադիր են կամ շատ ցանկալի: Կարգավորումների ցանկի վերևում ցանկալի է նշել մշակող ընկերության, ծրագրի և դրա պատկերակի (համապատասխանաբար ընկերության անվանումը, արտադրանքի անվանումը և կանխադրված պատկերակը) անունները:

Ներքևում՝ «Այլ կարգավորումներ» բաժնում, կան երկու պահանջվող պարամետր՝ «Փաթեթի նույնացուցիչ» և «Փաթեթի տարբերակ»: Նախնական տարբերակը սահմանվել է որպես 1.0, սակայն նույնացուցիչը պետք է ստեղծվի ձեռքով և, ցանկալի է, եզակի: Այն պետք է բաղկացած լինի երեք մասից՝ միմյանցից բաժանված կետերով՝ վերապահված «com» ​​բառը, ապա մշակող ընկերության անվանումը, իսկ վերջում՝ հենց հավելվածի անվանումը։

Դուք կարող եք փոխել հավաքման մնացած կարգավորումները ձեր հայեցողությամբ կամ ընդհանրապես չփոխել: Հիմնական բանն այն է, որ այժմ հավաքագրումն արդեն հնարավոր կլինի սկսել։ Դա անելու համար պարզապես սեղմեք «Build» կոճակը «Build Settings» պատուհանում և սպասեք, մինչև ծրագիրը մեզ տրամադրի APK ֆայլում փաթեթավորված պատրաստի հավելված :)

Եզրակացություն

Սրանով ավարտվում է Android-ի համար ամենապարզ հավելվածների ստեղծման մեր դաս-ակնարկը։ Որպեսզի կարողանաք կրկնել այն ամենը, ինչի մասին խոսեցինք, հոդվածի վերջում ես հղում կտամ արխիվին, որը կպահի խաղի բոլոր ռեսուրսները որպես առանձին թղթապանակ (եթե ցանկանում եք ամեն ինչ անել զրոյից) և ինչպես. ֆայլ unitypackage ընդլայնմամբ: Վերջինս թույլ է տալիս միանգամից ներմուծել ամբողջ նախագիծը Unity՝ ներառյալ կախվածությունները և այլն։

Մեր նախագիծը ներմուծելու համար (և, ի դեպ, ինտերնետից կամ Assets Store-ից ներբեռնված ցանկացած պլագին), դուք պետք է գնաք «Ակտիվներ» ընտրացանկը, ընտրեք «Ներմուծման փաթեթ» կետը և դրա մեջ «Պատվերով փաթեթ», ապա նշեք մեր ֆայլի ուղին և սեղմեք «Ներմուծում» կոճակը: Ի դեպ, նույն մենյուից («Ակտիվներ») կարող եք կատարել ձեր նախագծի ամբողջական կրկնօրինակում՝ պահպանելով այն նման միասնական փաթեթում՝ սեղմելով «Արտահանման փաթեթ» կետը։

Թվում է, թե ամեն ինչ :) Որպես մարդ, ով ինքն է տիրապետում Unity 3D-ին զրոյից, հոդվածում ես փորձեցի պատասխանել առավելագույն թվով հարցերի և ընդգծել շարժիչի հետ աշխատելու հիմնական նրբությունները, որոնք առաջանում են սկզբում: Բայց, երևի, սա որևէ մեկի համար բավարար չի լինի, հետևաբար, եթե հարցեր ունեք, կարող եք կապվել ինձ հետ կամ ուղղակիորեն փոստով կամ ֆորումով.

Բոլորիդ մաղթում եմ հաջողություն և բոլոր ծրագրերի հաջող իրականացում:

P.S. Թույլատրվում է ազատորեն պատճենել և մեջբերել այս հոդվածը, պայմանով, որ նշված է աղբյուրի բաց ակտիվ հղումը և պահպանվում է Ռուսլան Տերտիշնիի հեղինակությունը:

Նմանատիպ գրառումներ