აპლიკაციების შექმნა ანდროიდისთვის. Unity-ის გამოყენება აპლიკაციების დასამუშავებლად ანდროიდისთვის 3D თამაშის შექმნა

განვითარება მობილური აპლიკაციებიარის კომპიუტერული ინდუსტრიის ერთ-ერთი ყველაზე მომგებიანი პროფესია. ანდროიდის თამაშის შექმნა ასობით ან ათასობით დოლარი ღირს და მოგებამ შეიძლება მიაღწიოს მილიონ დოლარს. ამ მხრივ, ბევრი ადამიანი დაინტერესებულია ტელეფონისთვის აპლიკაციების შემუშავებით. ამ სტატიაში თქვენ შეისწავლით თუ როგორ უნდა შექმნათ 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 თამაშის შექმნა არ არის მარტივი, მაგრამ ძალიან მომგებიანი ბიზნესი. თუ გადაწყვეტთ თამაშის განვითარებას და მასზე ფულის გამომუშავებას, ჯერ შეიმუშავეთ იდეა. შემდეგი, დაწერეთ „დიზაინის დოკუმენტი“ და გადაწყვიტეთ თამაშის ძრავა, რომელსაც შეუძლია მაქსიმალურად გაზარდოს მისი პოტენციალი. ამის შემდეგ, შეგიძლიათ პირდაპირ გააგრძელოთ აპლიკაციის შექმნა კონსტრუქტორში.

ვიდეო

პროცესის შესახებ მეტი ინფორმაციის მისაღებად ანდროიდის თამაშების შექმნა, ნახეთ ამ აქტივობის ვიდეო სერიები.

ერთიანობა არის ძრავა, რომელზეც უმეტესობა თანამედროვე თამაშებისხვადასხვა პლატფორმაზე. ძრავის საშუალებით შესაძლებელია თამაშების შექმნა, რომლებიც ორიენტირებულია კომპიუტერებზე (Windows, Linux, MacOS), მობილურ ტელეფონებზე, პლანშეტ კომპიუტერებზე (Android, iOS) და კიდევ. სათამაშო კონსოლები PlayStation, Xbox, Nintendo.

როგორ შევქმნათ თამაშები Unity-ში?

ერთიანობა ეფუძნება კომპონენტზე ორიენტირებულ კონცეფციას. სინამდვილეში, ნებისმიერი თამაში შედგება დამატებითი კომპონენტებით განზავებული საგნების მასისგან. მაგალითად, პლატფორმის შექმნისას ვქმნით GameObject-ს, მას დამატებით ვამაგრებთ გრაფიკულ კომპონენტს, რომელიც პასუხისმგებელია პერსონაჟის ჩვენებაზე და საკონტროლო კომპონენტი, რომელიც უზრუნველყოფს პერსონაჟის კონტროლს მაუსის, კლავიატურის, ჯოისტიკის გამოყენებით. ან სენსორული ეკრანი. ძრავა არ აწესებს შეზღუდვებს ასეთი მოდულების რაოდენობაზე. ჩვენ შეგვიძლია დავამატოთ იმდენი კომპონენტი GameObject-ში, რამდენიც საჭიროა. ძრავზე ყველა სამუშაო ეფუძნება GameObject-ის შექმნას და მათზე შესაბამისი კომპონენტების გამოყენებას.

დამწყებთათვის შეიძლება შეცდომაში შეიყვანოს პროცესის აშკარა სიმარტივე, თუმცა ეს ასე არ არის. შექმნათ უნიკალური და პოპულარული თამაშითქვენ უნდა დაწეროთ ბევრი კომპონენტი ნულიდან. უფრო კონკრეტულად, Unity გარემოში ამას სკრიპტი ჰქვია. მშობლიური სკრიპტირების ენაა C#, მაგრამ JavaScript და Boo (Python-ის ამოჭრილი ვერსია) ასევე ნაწილობრივ გამოიყენება. საკუთარი კომპონენტების შექმნა ადვილი არ არის, შეიძლება ითქვას, რთული პროცედურაა, რომელიც პირდაპირ არის დაკავშირებული კლასიკურ პროგრამირებასთან. პროგრამირების საკმარისი დონის ცოდნის გარეშე, რთული იქნება.

მხარდაჭერილი პლატფორმები

ბევრი დიდი პროექტი უპირატესობას ანიჭებს Unity-ს ძრავასთან თავსებადი პლატფორმების უზარმაზარი სიის გამო. მზა აპლიკაციის გაშვება შესაძლებელია ნებისმიერ კომპიუტერულ ოპერაციულ სისტემაზე, პოპულარულ მობილურ პლატფორმებზე და SmartTV-ზე. რა შეგვიძლია ვთქვათ, თუნდაც ბრაუზერის თამაშები და აპლიკაციები კონკრეტული პლატფორმებისთვის ( Tizen OS-ის მსგავსად) უპირატესად განვითარებულია Unity-ში.

თუმცა, აქ ყველაფერი ასე გლუვი არ არის. საჭიროების შემთხვევაში შეგიძლიათ დაწეროთ კონკრეტული ალგორითმები დაბალი დონის კოდზე დაყრდნობით, იგივე ანდროიდისთვის საჭიროა ჯავის საფუძვლიანი ცოდნა.

იგივე ეხება iOS-ს. Სხვა iOS ფუნქციარომ მისი დამუშავება შესაძლებელია მხოლოდ Apple-ის კომპიუტერიდან ან პლანშეტიდან. Macbook-ის ან მსგავსი მოწყობილობის არარსებობის შემთხვევაში თამაშის გამოშვება სწრაფად ჩერდება და Unity-ს არაფერი აქვს საერთო, Apple თავად აწესებს მსგავს შეზღუდვას. დასკვნა მარტივია: თუ გეგმებში არის iOS-ის განვითარება, წინასწარ უნდა აირჩიოთ შესაფერისი მოწყობილობა შეკრებისთვის.

როგორ და სად განვავითაროთ თამაში ძრავზე?

ჩვენ შეგვიძლია განვახორციელოთ თამაშის განვითარების ხანგრძლივი პროცესი როგორც Windows-ში, ასევე Mac OS X-ში. უკვე არსებობს რედაქტორის ვერსიები Linux-ისთვის, მაგრამ ჯერჯერობით მათ სტაბილურ მუშაობაზე ვერ ვიმედოვნებთ. დეველოპერი დროის უმეტეს ნაწილს ატარებს თამაშის შექმნაზე Unity რედაქტორის შიგნით. ჩვენ ჯერ კიდევ ბევრი დრო გვაქვს სკრიპტის კოდის დასაწერად, შეგვიძლია შევქმნათ იგი როგორც სტანდარტულ MonoDevelop-ში, ასევე ნებისმიერ მესამე მხარის რედაქტორში. ახლა ისინი აქტიურად იყენებენ Visual Studio-ს, ასევე Sublime Text-ს, მაგრამ მხოლოდ შესაბამისი კონფიგურაციით.

Სალამი ყველას! ვისწავლე ამ ძრავზე თამაშების გაკეთება, მინდა გასწავლო იგივე. პირველ რიგში, ჩვენ გვჭირდება თავად Unity3d, ნებისმიერი 3D მოდელის რედაქტორი და სწორი მკლავები, რომლებიც იზრდება მხრებიდან.

1. პროგრამის სწავლა

განიხილეთ ზემოთ მოცემული ეკრანის სურათი:

• სცენა არის თქვენი შემოქმედებითი ქვიშის ყუთი.
• პროექტი - აქ არის ყველა ანიმაცია და მოდელი, ხმები და ტექსტურა.
• მოდელების ინსტალაციისთვის ზედა ხელსაწყოთა ზოლში აირჩიეთ Assets-Import New Asset. თქვენ ასევე შეგიძლიათ აქტივები-იმპორტის პაკეტი-მორგებული პაკეტი. მეორე შემთხვევაში, პაკეტი უნდა იყოს .unity გაფართოებაში.
• იერარქია - ყველა ობიექტი სცენაზე. იქ თქვენ ქმნით მშობლებს ობიექტისთვის. უბრალოდ გადაიტანეთ ობიექტი სხვაში იერარქიის მენიუში და ის დაერთვება. შედეგი იქნება ერთგვარი საქაღალდე.
• ინსტრუმენტთა პანელი - ინსტრუმენტების სია. აქ შეგიძლიათ ჩართოთ 2D, 3D რეჟიმი.
• ინსპექტორი - ობიექტის ფუნქცია, სადაც ამატებთ ანიმაციებს, სკრიპტებს და სხვა. იქ შეგიძლიათ გამოიყენოთ ინსტრუმენტები: გადაადგილება კამერა, გადაადგილება ობიექტი, გაჭიმვა, როტაცია ობიექტი.

ახლა თქვენ ხედავთ მასში ობიექტის მენიუს, შეგიძლიათ დაამატოთ ანიმაცია, სკრიპტები და სხვა.

მე ვფიქრობ, რომ ამ მენიუთი პრობლემები არ შეგექმნებათ.
დააწკაპუნეთ ნებისმიერი ობიექტის შესაქმნელად.

ზოგადად, პროგრამა შევისწავლეთ, მალე ჩვენი თამაშების დაწერა იქნება შესაძლებელი.

2. შექმენით მარტივი თამაში

ასევე შექმენით მთები და მუწუკები. შემდეგ ჩატვირთეთ Characher კონტროლერის პაკეტი პროექტში. შემდეგ ფანჯარაში ვეძებთ Standard assets-Characters controller პროექტით და ვირჩევთ პირველი პირის ხედს (კაფსულა) ან მესამე პირის ხედს (მექანიკოსი).
თუ პირველი ადამიანი, მაშინ უბრალოდ დადეთ იგი ადგილზე. თუ მესამედან, მაშინ უნდა ჩამოტვირთოთ ანიმაცია. მე ასევე გირჩევთ დააყენოთ სცენის განათება Create-Directional Light-ზე.

მუსიკის დასამატებლად გადაიტანეთ ის სასურველ ელემენტზე.
თამაში მზად არის, მაგრამ როგორ შევადგინოთ იგი?

ამისათვის გადადით File-Build-ის პარამეტრები-მოთამაშის პარამეტრებზე (ეტიკეტისთვის და სახელისთვის). აირჩიეთ პლატფორმა და 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$ .
• პრო. პერ $125 თვეშიმოიცავს ვერსიის ყველა უპირატესობას პლუსდა დამატებით პროფესიონალური სერვისი და პრემიუმ მხარდაჭერა. არანაირი შეზღუდვა ბრუნვაზე ან სახსრების ოდენობაზე.
• ცალკეული ვერსიები ბიზნესისთვის (გამოიყენება დიდი კომპანიების მიერ).

ამრიგად, მცირე ბიუჯეტის მქონე ინდი დეველოპერები კმაყოფილი უნდა იყვნენ ვერსიით პირადიან პლუსწინააღმდეგ შემთხვევაში მოგიწევთ გამოწერა პრო. ამ სტატიაში ჩვენ გამოვიყენებთ უფასო ვერსიაპირველი გაშვებისთვის.

ნაბიჯი 1 დააინსტალირეთ Unity

Unity-ის ინსტალაციის დასაწყებად, თქვენ უნდა შეხვიდეთ Unity Store ვებსაიტზე, სადაც მოგეთხოვებათ აირჩიოთ გამოწერის ტიპი. როგორც ზემოთ აღვნიშნეთ, ჩვენ ვირჩევთ პირადი.

ამის შემდეგ მოგეთხოვებათ დაეთანხმოთ გამოყენების პირობებს და ჩამოტვირთოთ ინსტალერი. თქვენ ასევე შეგიძლიათ შეამოწმოთ სისტემის მოთხოვნები Unity-თან მუშაობა.

ინსტალერის გაშვების შემდეგ, თქვენ მოგეთხოვებათ აირჩიოთ რომელი კომპონენტები დააინსტალიროთ. ვინაიდან ჩვენ გვჭირდება Android აპლიკაციის შექმნა, ჩვენ შევამოწმებთ ველს Android Build მხარდაჭერა. ასევე, სურვილის შემთხვევაში, Unity-ის ნაცვლად, შეგიძლიათ დააინსტალიროთ Visual Studio Community 2017 წელიპროგრამირებისთვის C#.

ამის შემდეგ რჩება მხოლოდ ინსტალაციის გზის არჩევა და Unity-ის ინსტალაციის დაწყება.

ნაბიჯი 2: რეგისტრაცია და დაყენება Unity

ინსტალაციის დასრულების და Unity-ის გაშვების შემდეგ, მოგვთხოვენ შეხვიდეთ ჩვენი ანგარიშით.

შემდეგ კვლავ მოგეთხოვებათ გამოწერის არჩევა, ჩვენ ასევე ყურადღებას გავამახვილებთ პერსონალურზე. ამ შემთხვევაში, თქვენ უნდა დაადასტუროთ, რომ კომპანიის წლიური შემოსავალი 100 000 დოლარზე ნაკლებია, ან რომ Unity გამოიყენება სასწავლო მიზნებისთვის.

დასასრულს, შემოთავაზებულია მცირე გამოკითხვის ჩატარება, რომელშიც თქვენ უნდა უპასუხოთ რას აკეთებთ და რა მიზნით დააინსტალირეთ Unity.

ნაბიჯი 3. შექმენით ახალი პროექტი

Unity-ის კონფიგურაციის შემდეგ, ჩვენ მივდივართ ეკრანზე პროექტის არჩევისთვის / შესაქმნელად. Დააკლიკე აქ ახალითქვენი ახალი პროექტის შესაქმნელად.

ამის შემდეგ, ფანჯარაში, რომელიც გამოჩნდება, მოგეთხოვებათ შეიყვანოთ პროექტის სახელი და დირექტორია, სადაც ის განთავსდება. ასევე არ დაგავიწყდეთ ყუთის შემოწმება 3Dრედაქტორის 3D რეჟიმში გამოსაყენებლად.

როდესაც ამას დაასრულებთ, დააწკაპუნეთ შექმენით პროექტიპროექტის შესაქმნელად. ამის შემდეგ, რედაქტორის ფანჯარა გაიხსნება წინასწარ გენერირებული სცენით.

ჩვენ ჯერ არ შევეხებით პროგრამირების სირთულეებს და მაგალითისთვის ავიღოთ დასრულებული თამაში. ამისათვის არსებობს აქტივების მაღაზია, რომელიც შეიცავს უამრავ მზა მოდელს, ანიმაციას, ხმებს (და თუნდაც თამაშებს), როგორც ფასიან, ასევე უფასო.

Asset Store-ის გასახსნელად, მენიუში გჭირდებათ ფანჯარააირჩიე აქტივების მაღაზია(გასაღების კომბინაცია ctrl-9).

გაიხსნება მაღაზიის ფანჯარა. შეიყვანეთ საძიებო ზოლში " Flappy bird სტილის მაგალითი თამაშიდა გახსენით უფასო მაგალითი, რომელსაც გამოვიყენებთ ჩვენს პროექტში.

დაწკაპუნება ჩამოტვირთვადა ამგვარად ჩამოტვირთვის შემდეგ, შეგიძლიათ შემოიტანოთ იგი თქვენს პროექტში. ამისათვის დააწკაპუნეთ იმპორტი, რის შემდეგაც გამოჩნდება გაფრთხილება, რომ პროექტის პარამეტრები შეიცვლება იმპორტის შემდეგ.

იმპორტზე დათანხმების შემდეგ, ნახავთ ფანჯარას, რომელშიც უნდა აირჩიოთ კომპონენტების იმპორტი. აირჩიეთ ყველა და დააწკაპუნეთ იმპორტი.

იმპორტის დასრულების შემდეგ, თქვენ იხილავთ ახალ ფაილებს Project Browser-ში. ეს არის თამაშის ფაილები. რედაქტორში სცენის გასახსნელად, გააფართოვეთ ფლაპი ჩიტისტილი - სცენებიდა ორჯერ დააწკაპუნეთ მთავარი.

შედეგად, თამაშის სცენა გამოჩნდება 3D რედაქტორის ფანჯარაში.

თქვენ შეგიძლიათ შეამოწმოთ როგორ მუშაობს თამაში პირდაპირ Unity-ში ღილაკზე დაჭერით თამაშირედაქტორის ფანჯრის ზემოთ.

ნაბიჯი 4 Android Tools-ის კონფიგურაცია

Შენიშვნა:თუ იყენებთ ანდროიდის სტუდია, მაშინ თქვენ უკვე გაქვთ ყველაფერი დაინსტალირებული საჭირო კომპონენტებიასე რომ თქვენ შეგიძლიათ უსაფრთხოდ გადახვიდეთ შემდეგ ეტაპზე.

Android-ზე მიღებული თამაშის ასაწყობად, თქვენ უნდა დააინსტალიროთ შემდეგი ინსტრუმენტები:

• ჯავის განვითარების ნაკრები (JDK).მისი ჩამოტვირთვა შეგიძლიათ Java-ს ვებსაიტიდან. ლინკზე დაწკაპუნებით, თქვენ ნახავთ ზევით ჯავის პლატფორმა (JDK), დააკლიკეთ ჩამოტვირთვაწარწერის გვერდით, შემდეგ აირჩიეთ თქვენი ოპერაციული სისტემადა დაიწყე ჩამოტვირთვა. ამის შემდეგ უბრალოდ მიჰყევით ინსტალერის მითითებებს.
• Android SDK. ყველაზე მეტად მარტივი გზითუახლესი ვერსიის ინსტალაციისთვის არის Android Studio-ს ჩამოტვირთვა, რომლითაც ეს SDK მოდის. ამისათვის გადადით Android Studio-ს ვებსაიტზე და დააწკაპუნეთ ჩამოტვირთეთ Android Studio. Android Studio ინსტალერი აყენებს Android SDK-ის ძირითად კომპონენტებს, რომლებიც საჭიროა Android-ის განვითარებისთვის.

ნაბიჯი 5. მოამზადეთ პროექტი გაშვებისთვის

პირველ რიგში, თქვენ უნდა შეცვალოთ განვითარების პლატფორმა Android-ზე. ამისათვის Unity-ში გახსენით File მენიუ და აირჩიეთ Build Settings.

ფანჯარაში, რომელიც გამოჩნდება, აირჩიეთ Androidდა შემდეგ დააჭირეთ გადართვის პლატფორმა.

პლატფორმის შეცვლა გვეუბნება, რომ ჩვენ შევქმნით Android აპს. ეს ნიშნავს, რომ როდესაც ჩვენ ვაშენებთ აპლიკაციას, Unity შექმნის APK ფაილი. პლატფორმის შეცვლა ასევე აიძულებს Unity-ს ხელახლა შემოიტანოს პროექტში არსებული ყველა აქტივი. ამას დიდი დრო არ დასჭირდება მცირე პროექტზე, მაგრამ გახსოვდეთ, რომ ამ ოპერაციას შეიძლება დიდი დრო დასჭირდეს დიდ პროექტებზე.

ახლა ჩვენ უნდა მივცეთ პაკეტის სახელი განაცხადისთვის.

Შენიშვნა:პაკეტის სახელი არის უნიკალური იდენტიფიკატორი აპლიკაციისთვის და დაწერილია საპირისპირო DNS სტილში ფორმატში com.CompanyName.ProductName. განაცხადის გამოქვეყნების შემდეგ Google Playპაკეტის სახელი აღარ შეიცვლება.

ამისათვის გადადით მენიუში რედაქტირებადა აირჩიე პროექტის პარამეტრები - მოთამაშე.

Unity-ის მარჯვენა მხარეს გაიხსნება ფანჯარა მრავალი განსხვავებული პარამეტრით, როგორიცაა აპლიკაციის ვერსია, სამიზნე და მინიმალური SDK, ხატის შერჩევა და ა.შ. აქ ჩვენ გვჭირდება ბლოკში სხვა პარამეტრებიიპოვე იდენტიფიკაციადა დააყენეთ პაკეტის სახელი ველში პაკეტის სახელი. თქვენ ასევე შეგიძლიათ შეცვალოთ სხვა პარამეტრები, თუ გსურთ.

ახლა რჩება მხოლოდ Android SDK-ისა და JDK-ის გზის დაზუსტება. ამისათვის გადადით მენიუში და აირჩიეთ რედაქტირება-პრეფერენციები.

ფანჯარაში, რომელიც გამოჩნდება, გადადით გარე ინსტრუმენტებიდა მინდვრებში SDKდა JDKმიუთითეთ შესაბამისი ბილიკები და შემდეგ დახურეთ ფანჯარა.

ნაბიჯი 6: აპლიკაციის შექმნა და გაშვება

დროა შექმნათ თქვენი პირველი Unity აპი. ამისათვის აირჩიეთ მენიუდან ფაილი - Build Settings. გაიხსნება ფანჯარა, რომელშიც თქვენ უნდა დაამატოთ სცენა, რომლის აწყობა გსურთ. ვინაიდან ჩვენ უკვე გვაქვს ეს სცენა გახსნილი რედაქტორში, უბრალოდ დააწკაპუნეთ დაამატეთ ღია სცენებიასამბლეის დასამატებლად, დამატების შემდეგ ნახავთ მას სცენების სიაში.

რჩება მხოლოდ დაჭერა აშენება, რის შემდეგაც 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 ძრავთან მუშაობას.

თამაშობ კომპიუტერულ თამაშებს? თუ ასეა, მაშინ, რა თქმა უნდა, შემდეგი თამაშის ბლოკბასტერის გავლის პროცესში, ხანდახან გაგიჩნდათ აზრები, როგორიცაა: "მაგრამ აი, არასწორად მოვიქცეოდი!". გსურთ თავად იყოთ დეველოპერი? მაშინ, გთავაზობთ პატარა, მაგრამ ძალიან გასართობ „თავგადასავალს“;)

რა არის ძრავა და რატომ არის საჭირო?

ადრე, ჯერ კიდევ პირველი კომპიუტერების დღეებში, თამაშები და პროგრამები იქმნებოდა ეგრეთ წოდებული "hardcore" მეთოდით. ანუ, სრულფასოვანი განვითარებისთვის საჭირო იყო საკმაოდ გამოცდილი პროგრამისტი, რომელმაც საფუძვლიანად იცის მისი პროგრამირების ენა და შეუძლია დაწეროს თითქმის მთელი თამაში (პიქსელური გრაფიკისა და სპეციალური ეფექტების ჩათვლით!) მარტივ 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 ფანჯარა არის ინსპექტორის ფანჯრის ქვედა ნაწილი, რომელიც აჩვენებს პროექტის ფანჯარაში შერჩეული ობიექტის ან ფაილის გადახედვას.

ყოველივე ზემოთქმულის გარდა, ყურადღება მიაქციეთ სამ ღილაკს ზედა ცენტრში. ისინი საშუალებას გაძლევთ დაიწყოთ თქვენი პროექტი, შეაჩეროთ ის (ზოგჯერ სასარგებლოა გამართვისას, რომ ნახოთ რა კეთდება იერარქიაში, მაგალითად) და, შესაბამისად, გამორთოთ იგი.

ჩვენ შევქმნით მუსიკალური ინსტრუმენტის სიმულატორს: ინდურ ხალხურ დასარტყამს სახელად „ტაბლა“, ამიტომ, დასაწყებად პროექტში შევქმნით ორ ცარიელ საქაღალდეს, რომელშიც შეინახება ხმები და სურათები. თქვენ შეგიძლიათ შექმნათ ახალი საქაღალდე პროექტის ნავიგატორის ფანჯარაში (პროექტი) კონტექსტური მენიუს დარეკვით და „შექმნა“ სიაში „საქაღალდის“ პუნქტის არჩევით.

აქ ღირს რამდენიმე სიტყვის თქმა იმის შესახებ, თუ როგორ უნდა დაერქვას ეს საქაღალდეები. მარტივი თამაშისთვის, ჩვენი სიმულატორის მსგავსად, პრინციპში, საქაღალდეები შეიძლება "დაარქვეს" როგორც მოგწონთ, თუმცა არის მინიმუმ ორი სახელი, რომელიც უკეთესია არ გამოიყენოთ, რადგან ისინი დაცულია ძრავით. ეს არის სახელები რესურსები და დანამატები. დიდ პროექტებში რესურსების საქაღალდე დაუყოვნებლივ იქმნება და მასში უკვე ინახება თამაშის ყველა „სათადარიგო ნაწილი“ (სურათები, ხმები, მოდელები, ტექსტურები და პრეფაბები) (დალაგებულია ქვესაქაღალდეების მიხედვით). Plugins-ში, როგორც სახელი გულისხმობს, ინახება მესამე მხარის ფუნქციების ყველა დამატებითი კომპლექტი (ე.წ. "აქტივები" (აქტივები)), რომელთაგან საკმაოდ ბევრია Asset Store-ში - Unity3D-ის გაფართოებების მაღაზია.

ფაილების იმპორტი და თამაშის ობიექტების შექმნა

ახალი თამაშის პროექტის შექმნამდე მიზანშეწონილია წინასწარ მოამზადოთ მისი ფუნქციონირებისთვის საჭირო ყველა ფაილი. ჩვენს შემთხვევაში, ეს ფაილები არის სურათები და ხმები. პროექტში მათი იმპორტის უმარტივესი გზაა მათი უბრალოდ გადათრევა და ჩაშვება სასურველ საქაღალდეში. დავიწყოთ სურათებით...

მას შემდეგ, რაც სურათები გამოჩნდება ჩვენს Images საქაღალდეში, საჭიროა მათი ოდნავ შესწორება:

ფაქტია, რომ ნაგულისხმევად Unity3D შეკუმშავს პროექტში დამატებულ ყველა სურათს ხარისხის დაკარგვით. თუ ასეთი დანაკარგი არ გვჭირდება (განსაკუთრებით HD გრაფიკის მქონე თამაშებს), მაშინ უნდა ავირჩიოთ თითოეული სურათი და შევცვალოთ "Format" პარამეტრის მნიშვნელობა "Compressed"-დან "Truecolor"-ზე "Default" ჩანართში. ინსპექტორის ფანჯარა. თქვენ ასევე შეიძლება დაგჭირდეთ "Max Size" პარამეტრის შეცვლა, თუ ის უფრო მცირეა ვიდრე სურათის რეალურ სიგანეზე (ნაგულისხმევი არის 1024 პიქსელი). ყველა ცვლილების შემდეგ, თქვენ უნდა გახსოვდეთ, რომ დააწკაპუნოთ ღილაკზე "Apply" მათ გამოსაყენებლად. საჭიროების შემთხვევაში, ჩვენ ვასრულებთ მსგავს მოქმედებებს ყველა სხვა სურათზე.

ახლა მოდით შევქმნათ თამაშის ობიექტები ჩვენი სურათებიდან. ამისათვის უბრალოდ გადაიტანეთ სასურველი სურათი იერარქიის ფანჯარაში. სურათი ან 3D მოდელი ავტომატურად გადაიქცევა თამაშის ობიექტად და გამოჩნდება საწყის კოორდინატთა წერტილში კამერის წინ.

პირველ რიგში დავამატეთ ფონის სურათი, რომელიც უნდა იყოს ნაჩვენები სრულ ეკრანზე. თქვენ შეგიძლიათ შეამოწმოთ არის თუ არა ეს ასე იერარქიის ფანჯარაში კამერის არჩევით და იმის დანახვით, თუ როგორ არის ნაჩვენები მისი ჩარჩო. ზემოთ მოცემულ სკრინშოტში ხედავთ, რომ ჩვენი ფონის ნაწილი რჩება კამერის ხედის მიღმა, ამიტომ ჩვენ უნდა დავარეგულიროთ ამ ხედის ზომა კადრის პირდაპირ სცენაზე გადათრევით ან ინსპექტორის ფანჯარაში "Size" პარამეტრის რედაქტირებით. ჩვენს შემთხვევაში, ჩვენ უნდა შეგვეცვალა ნაგულისხმევი მნიშვნელობა (5) 5.4-ზე.

ესე იგი, კამერას აღარ ვეხებით, დანარჩენ სურათებს ვამატებთ და ვასწორებთ. დამატებისას ვხედავთ, რომ ზოგიერთი მათგანი ძალიან დიდია ჩვენი თამაშისთვის. თქვენ შეგიძლიათ შეამციროთ ისინი ფიზიკურად გრაფიკულ რედაქტორში, ან ძრავის საშუალებით. ვცადოთ ბოლო მეთოდი. ამისათვის შეარჩიეთ სურათი იერარქიის ფანჯარაში და ინსპექტორის ფანჯარაში შეცვალეთ "Scale" მნიშვნელობები X და Y კოორდინატებისთვის 1-დან 0.5-მდე (ანუ შეამცირეთ ნახევარით). იმავე ადგილას, მიზანშეწონილია გადაფარვების თავიდან ასაცილებლად, თამაშის ყველა ობიექტს (ფონის გარდა) მივანიჭოთ ფენების არანულოვანი რიგი (Order in Layer):

თამაშის ობიექტების სურათებიდან მომზადების ბოლო ნაბიჯი იქნება მათზე კოლაიდერების „დაკიდება“. Unity3D-ში კოლაიდერები გამოიყენება ობიექტებს შორის ურთიერთქმედების დეტექტორებად. ანუ, ფაქტობრივად, ჩვენს სურათზე არის დაყენებული ვირტუალური გარსი, რომელსაც შეუძლია დაარეგისტრიროს მასზე შეხება.

ობიექტზე კოლაიდერის დასამატებლად აირჩიეთ ის იერარქიის ფანჯარაში და შემდეგ დააწკაპუნეთ ღილაკზე „კომპონენტის დამატება“ ინსპექტორის ფანჯარაში. კომპონენტების ჩამონათვალში, რომელიც გამოჩნდება, ჩვენ ვეძებთ Physics 2D-ს (ჩვეულებრივი 3D ფიზიკა არ იმუშავებს ჩვენს რეჟიმში) და ყველა ვარიანტიდან ჩვენთვის ყველაზე შესაფერისია "Circle Collider 2D". ჩვენ ვირჩევთ მას. მწვანე შტრიხი გამოჩნდება ჩვენი ობიექტის გარშემო, რომელიც აჩვენებს კოლაიდერის საზღვრებს. რჩება მხოლოდ "Is Trigger" ჩამრთველის შემოწმება ისე, რომ ჩვენი კოლაიდერი მხოლოდ დაწკაპუნებებს აღრიცხავს და აღარ ურთიერთქმედებს მიმდებარე თამაშის სივრცესთან:

მსგავსი ქმედებები მეორდება ყველა დარჩენილი ობიექტისთვის. მხოლოდ ჩვენი ფონი განსხვავდება სხვა ობიექტებისგან. ამისათვის ჩვენ გამოვიყენებთ Box Collider 2D-ს და დავაყენებთ პოზიცია Z იყოს ნულზე მეტი, რათა გადავიტანოთ კოლაიდერი და თავად ფონი უკანა პლანზე (ეს მოგვიანებით დაგვჭირდება).

ხმასთან მუშაობა

Unity 3D-ში ხმით, ერთი შეხედვით, ყველაფერი გარკვეულწილად დამაბნეველია. ოღონდ ვცადოთ თანმიმდევრობით გავარკვიოთ :)

უპირველეს ყოვლისა, ჩვენ უნდა გადავიტანოთ ყველა ბგერა Sounds საქაღალდეში და ცოტათი შევცვალოთ ისინი:

თუ თქვენი ყველა ბგერის ხმის დონე თავდაპირველად მორგებულია, მაშინ ყველაფერი რაც თქვენ უნდა გააკეთოთ არის გამორთოთ 3D ხმის დამუშავება. 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/ - გაკვეთილების სერია ჰაბრაჰაბრზე სამგანზომილებიანი თამაშების შექმნის შესახებ;
• http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - Microsoft-ის ოფიციალური C# მითითება რუსულ ენაზე.

ისე, რომ დიდი ხნის განმავლობაში არ გავაჭიანუროთ, მე ვთავაზობ დაუყოვნებლივ შექმნას პირველი სკრიპტი. სკრიპტების ქვეშ, თუ ისინი ბევრია, უმჯობესია გამოვყოთ ცალკე საქაღალდე, მაგრამ ჩვენი თამაში იქნება მარტივი, ასე რომ ჩვენ შეგვიძლია შევქმნათ სკრიპტი პირდაპირ პროექტის root საქაღალდეში. ამისათვის გამოიძახეთ კონტექსტური მენიუ პროექტის ფანჯარაში, აირჩიეთ სია შექმნა და დააწკაპუნეთ "C # Script". მოდით დავასახელოთ ჩვენი ახალი სკრიპტი, მაგალითად, Sounds და გავხსნათ ორმაგი დაწკაპუნებით. სტანდარტული მეთოდების განახლება და დაწყება ამოღების შემდეგ, შემდეგ კი, საჭიროების დარეგისტრირების შემდეგ, ვიღებთ შემდეგ სკრიპტს:

თუ არ გაქვთ რედაქტორის კონფიგურაცია, მაშინ ჩვენი სკრიპტი გაიხსნება MonoDevelop-ში. მოდით შევხედოთ მის სტრუქტურას...

სინამდვილეში, ყოველი C# სკრიპტი შედგება სამი ძირითადი ნაწილისგან:

1. ზემოთ ჩამოთვლილია ბიბლიოთეკები, რომლებიც უნდა იყოს დაკავშირებული სკრიპტის მუშაობისთვის (მაგალითად, "Using Unity.Engine" აკავშირებს თავად ძრავის მუშაობას, ხოლო "Using System.Collections" არის ბიბლიოთეკა, რომელიც შეიცავს რიცხვს. ჩაშენებული კლასები სკრიპტის სხვადასხვა სისტემებში მუშაობისთვის).
2. კლასის და ცვლადის დეკლარაცია. არ არსებობს სკრიპტის კონცეფცია C#-ში, როგორც ასეთი. სამაგიეროდ გამოიყენება „კლასის“ ცნება, რომელიც მოიცავს მთელ რიგ მეთოდებსა და ფუნქციებს. თუმცა, სინამდვილეში, Unity 3D-ის კონტექსტში, ეს თითქმის იგივეა :) მთავარია გვახსოვდეს, რომ კლასის სახელი უნდა ემთხვეოდეს იმ სახელს, რომელიც ჩვენ მივეცით სკრიპტს. C#-ში ცვლადების თავისებურება ის არის, რომ ისინი (გარდა დროებითისა, რომელიც თავად სკრიპტშია გამოცხადებული) უნდა იყოს აკრეფილი. პრაქტიკაში ეს ნიშნავს, რომ ცვლადისთვის უნდა იყოს მითითებული წვდომის დონე (პირადი ან საჯარო) და ტიპი (int, float, bool ან, როგორც სკრიპტში გვაქვს, AudioClip), ამავდროულად შეგიძლიათ მისცეთ ცვლადი. დაასახელეთ რომელიმე. ან შეგიძლიათ დაუყოვნებლივ მიანიჭოთ მას მნიშვნელობა.
3. მეთოდებისა და ფუნქციების ნაკრები. მეთოდი C#-ში არის თითქმის ნებისმიერი ფუნქცია, რომელიც ასრულებს გარკვეულ მოქმედებებს. პრინციპში, Unity 3D-ის ლიტერატურაში მათ ფუნქციებს უწოდებენ, მაგრამ თუ ვსაუბრობთ C #-ზე, როგორც ცალკე პროგრამირების ენაზე, მაშინ ეს, ბოლოს და ბოლოს, მეთოდებია :). წმინდა ფუნქციები Unity-ში არის, მაგალითად, სტანდარტული ფუნქციები ხმის გამოსატანად, GUI ელემენტების დახატვისთვის და ა.შ., რომლებიც გამოიყენება მეთოდებში.

ახლა უკვე ვიცით სკრიპტის სტრუქტურა, ადვილია მისი მნიშვნელობის გაგება, რაც ჩამოყალიბებულია შემდეგზე... კლასში (script) Sounds ვაცხადებთ AudioClip ტიპის 9 ცვლადს იმ სახელებით, რომლებიც გვჭირდება მოხერხებულობისთვის. მათი გარჩევა. ვაქცევთ მათ აუცილებლად საჯარო (პირადი არ იქნება ნაჩვენები რედაქტორში და დაგვჭირდება მათზე ხმების „დაკიდება“ რედაქტორის მეშვეობით). შემდეგ კი სკრიპტის სხეულში ვიყენებთ სტანდარტულ მეთოდს "void OnMouseDown ()". ადრე ის მხოლოდ მაუსის დაწკაპუნების დამუშავებაზე იყო პასუხისმგებელი, მაგრამ ახალ ვერსიებში ის ასევე განმარტებულია, როგორც სენსორული ეკრანის შეხება. მასში ვწერთ პირობებს, რომლითაც ვამოწმებთ დაჭერილი კოლაიდერების სახელებს და თუ რომელიმე მათგანის დაჭერას აღმოვაჩენთ, გამოვყოფთ შესაბამის ხმას (ვიყენებთ სტანდარტულ audio.PlayOneShot(); ფუნქციას).

კოდის დაწერისას, ფრთხილად იყავით, რომ ჩართოთ ყველა გახსნის და დახურვის ფრჩხილები, წინააღმდეგ შემთხვევაში თქვენ მუდმივად მიიღებთ შეცდომის ანგარიშებს კონსოლში და საერთოდ ვერ შეძლებთ თქვენი პროექტის გაშვებას! ასევე ყურადღება მიაქციეთ დიდი ასოების გამოყენებას მეთოდებისა და ფუნქციების დასახელებაში. ისინი ასევე ხშირად არიან შეცდომების მიზეზი. და, რა თქმა უნდა, დააკვირდით ყველა ნიშანს (პერიოდები, ორწერტილები და ფრჩხილები), მოკლედ, ენის სინტაქსი. თავიდან გაგიჭირდება, მაგრამ დროთა განმავლობაში დაიწყებ წერას ნულიდან უშეცდომოდ!

როდესაც სკრიპტი მზად იქნება, შეარჩიეთ იგი და ინსპექტორის ფანჯარაში მიანიჭეთ სხვადასხვა ხმა თითოეულ ცვლადს. ახლა ჩვენ უბრალოდ უნდა გამოვიყენოთ ჩვენი სკრიპტი სცენის ობიექტებზე. ამის გაკეთების უმარტივესი გზა კიდევ ერთხელ არის სკრიპტის გადათრევა პირდაპირ სასურველ თამაშის ობიექტზე იერარქიის სიაში:

თუ სკრიპტი სწორად იყო გადმოტანილი, მაშინ ის უნდა გამოჩნდეს ინსპექტორის ფანჯარაში იმ ობიექტის გვერდით, რომელზეც ის გადავიტანეთ. შესაბამისად, ჩვენ სკრიპტს ვათრევთ ყველა იმ ობიექტზე, რომელიც უნდა ჟღერდეს თამაშში და შეგვიძლია ვცადოთ მისი გაშვება. როდესაც დააჭერთ ჩვენს თამაშის ღილაკებს, ახლა, ბოლოს და ბოლოს, მითითებული ხმა გაისმის!

შესავალი GUI-ში

პრინციპში, თამაში ჩვენთან უკვე ფუნქციონირებს, მაგრამ რატომღაც ძალიან "მელოტია". მასში რაღაც აკლია... ან, ყოველ შემთხვევაში, წარწერა სახელწოდებით, რომელიც ჩვენს წინ არის! სხვა სიტყვებით რომ ვთქვათ, თქვენ უნდა განახორციელოთ რაიმე სახის გასაგები მომხმარებლის ინტერფეისი.

სინამდვილეში, GUI არის ინგლისური ენის აბრევიატურა. "გრაფიკული მომხმარებლის ინტერფეისი", ანუ გრაფიკული მომხმარებლის ინტერფეისი. ტრადიციულად, იგი მოიცავს ისეთ კომპონენტებს, როგორიცაა:

• ღილაკები;
• ფანჯარა;
• ტექსტის სფეროები;
• მოსანიშნი ველები და/ან რადიო ღილაკები;
• სლაიდერები (გადახვევის ზოლები) და ა.შ.

Unity 3D-ში ეს ყველაფერი (და კიდევ რაღაც ამაზე მეტი) სრულად არის წარმოდგენილი. მთავარია ისწავლო მისი გამოყენება! მოდით შევხედოთ, თუ როგორ შეუძლია Unity-ის GUI შექმნას მარტივი სათაური.

ამისათვის შექმენით ახალი სკრიპტი სახელწოდებით Interface და შეცვალეთ იგი შემდეგნაირად:

ყურადღებით გაითვალისწინეთ სკრიპტი ეკრანის სურათზე. აქ ჩვენ ვწერთ მხოლოდ ერთ საჯარო ცვლადს GUIStyle ტიპის, რომელიც ჩვენთვის ახალია. ეს ტიპი საშუალებას გაძლევთ ვიზუალურად შეცვალოთ იმ ელემენტების გარეგნობა, რომლებსაც ეს სტილი ენიჭება. სტილები სასარგებლოა, როდესაც არსებობს ერთი და იგივე ტიპის ინტერფეისის მრავალი ელემენტი (მაგალითად, ღილაკები), მაგრამ მათ უნდა ჰქონდეთ განსხვავებული სახე.

შემდეგ ვქმნით ღილაკს ("GUI.Button"), რომელსაც აქვს შემდეგი სინტაქსი: მდგომარეობა - 4 კოორდინატი (ჰორიზონტალური შეწევა მარცხენა კიდიდან, ვერტიკალური შეწევა ზედა კიდიდან, სიგანე, სიმაღლე) - ხილული ტექსტი ბრჭყალებში და შემდგომი. სურვილისამებრ, სტილის მითითება. საჭირო ფუნქციები იწერება ღილაკის პირობაში. ჩვენს შემთხვევაში, ჩვენ დავარეგისტრირეთ გადასვლა დეველოპერების საიტზე ("Application.OpenURL("");").

GUI სკრიპტებს შეუძლიათ იმუშაონ ნებისმიერი თამაშის ობიექტებიდან, მაგრამ, როგორც წესი, მათ ურჩევენ მათ კამერაზე „დაკიდებას“, რასაც ჩვენ გავაკეთებთ სკრიპტის მთავარ კამერის ობიექტზე გადათრევით. ახლა თუ ავირჩევთ იერარქიის ფანჯარაში, მაშინ Inspector-ის ფანჯარაში შევძლებთ დავინახოთ ჩვენი სტილის საჯარო ცვლადი, მისი გაფართოებით მივიღებთ სრულ წვდომას ამ სტილის პარამეტრებზე!

ჩვენ შეგვიძლია განვსაზღვროთ ტექსტის ფერი და ტექსტურა ფონის ნებისმიერ სიტუაციაში (ღილაკისთვის, თქვენ უნდა დაარეგისტრიროთ მისი სამი ვარიანტი (ნორმალური - ნორმალური ხედი, Hover - hover-ზე და Active - დაწკაპუნებით), დააყენოთ padding და დაარეგულიროთ შრიფტი. ნაგულისხმევად, Unity 3D-ში ერთადერთი ხელმისაწვდომი შრიფტი არის Arial, თუმცა, თქვენ შეგიძლიათ ხელით ჩატვირთოთ ნებისმიერი სხვა შრიფტი პროექტში და გამოიყენოთ იგი "შრიფტის" ველში, დააყენოთ ყველა დაკავშირებული პარამეტრი.

რაც საინტერესოა და ამავდროულად არც თუ ისე მოსახერხებელია, რომ GUI ელემენტები არ არის ნაჩვენები სცენაზე სანამ არ დავიწყებთ პროექტს, ამიტომ თითოეული ელემენტის პარამეტრების კორექტირებას შეიძლება დიდი დრო დასჭირდეს. მოდით გავუშვათ პროექტი და ვნახოთ, როგორი იქნება ზემოთ შექმნილი ჩვენი ღილაკი:

ინტერფეისის შეცვლა მდგომარეობისა და სტატიკური ცვლადების მიხედვით

ჩვენ უკვე ბევრი რამ გავაკეთეთ, მაგრამ გაუმჯობესების ადგილი ყოველთვის არის :) ამიტომ, მე გთავაზობთ, როგორც ბოლო მაგალითს, შევქმნათ დახმარების ფანჯარა, რომლითაც ჩვეულებრივ დეველოპერები აწვდიან თავიანთ თამაშებს და აპლიკაციებს. ამისათვის დაამატეთ სურათი ასეთი ღილაკისთვის კითხვის ნიშნის სახით საქაღალდეში სურათებით და გააკეთეთ მისგან თამაშის ობიექტი. დავკიდოთ მასზე კოლაიდერი და დავწეროთ სკრიპტი სახელწოდებით, მაგალითად, „დახმარება“ შემდეგი შინაარსით:

ამ სკრიპტში გვაქვს ორი ცვლადი. პირველი ცვლადი განსაზღვრავს სკინს, რომელიც გამოყენებული იქნება ამ კლასში აღწერილი ინტერფეისის ყველა ელემენტისთვის. სტილისგან განსხვავებით, რომელიც ზემოთ განვიხილეთ, სკინები საშუალებას გაძლევთ შეცვალოთ არა მხოლოდ ცალკეული ელემენტის გარეგნობა, რომელსაც ისინი ანიჭებენ, არამედ გარკვეული ტიპის ყველა ელემენტს ერთდროულად. გარდა ამისა, სტილისგან განსხვავებით, სკინები არ არის მინიჭებული ელემენტებზე, არამედ დეკლარირებულია დაუყოვნებლივ მთელი მეთოდისთვის და მუშაობს მანამ, სანამ სხვა სკინი არ გამოცხადდება. ასევე უნდა გვახსოვდეს, რომ სკინები არსებობს არა მხოლოდ როგორც ცვლადები, არამედ როგორც ინდივიდუალური ფაილები. ამიტომ, სკინის გამოცხადებამდე, დაუყოვნებლივ უნდა შექმნათ იგი "პროექტის" ფანჯარაში კონტექსტური მენიუდან: "Create" - "GUI Skin".

მეორე ცვლადი, რომელიც გვაქვს, არის ლოგიკური (ან სხვაგვარად ლოგიკური). მას შეიძლება ჰქონდეს მხოლოდ ორი მნიშვნელობა: "true" (true) ან "false" (false). მისი ორობითი ბუნების გამო, ასეთი ცვლადი შესანიშნავია ყველა სახის გადამრთველების დასანერგად. ჩვენს შემთხვევაში, ის იქნება პასუხისმგებელი ჩვენი თამაშის აღწერის ტექსტის ჩვენებაზე.

თუმცა, თუ კარგად დააკვირდებით, შეამჩნევთ, რომ ბოლო ცვლადს აქვს ერთი შესანიშნავი პარამეტრი – „სტატიკური“. ამ პარამეტრის ცვლადებში დამატება საშუალებას გაძლევთ გახადოთ ისინი სტატიკური და შეხვიდეთ მათზე სხვა სკრიპტებიდან!

მაგრამ დაუბრუნდით დანარჩენ კოდს. "void OnMouseDown()" მეთოდი ჩვენთვის აქ უკვე ნაცნობი იქნება "isVisible" ცვლადის გადამრთველი მარტივი პირობის გამოყენებით. თუმცა, მდგომარეობის შემდეგ არსებობს სხვა ფუნქცია. ეს ფუნქცია ("Debug.Log();") გამოიყენება კონსოლში ჩვენთვის საჭირო ცვლადების მნიშვნელობების "on the fly" გამოსატანად (მათ შევიყვანთ ბრჭყალების გარეშე). როგორც ხედავთ, ფუნქციის შიგნით შეგიძლიათ დააკავშიროთ როგორც უცვლელი ტექსტი (ბრჭყალებში დაწერილი) ასევე ცვლადები (ბრჭყალებში). მთავარი ის არის, რომ ყველა მონაცემს შორის უნდა იყოს ნიშანი "+".

შემდგომში სკრიპტის ტექსტში გვაქვს ინტერფეისის დახატვის მეთოდი ("void OnGUI()()"), რომლის შიგნითაც ვხედავთ ახალი სკინის დეკლარაციას ("GUI.skin = HelpSkin;") და ახალს. GUI.Box ტიპის ინტერფეისის ელემენტი. ღილაკებისგან განსხვავებით, ყუთი არის არააქტიური ელემენტი და ჩვეულებრივ ემსახურება სხვადასხვა ტექსტის ან გრაფიკული მონაცემების ჩვენებას.

ყურადღება მიაქციეთ, თუ როგორ დავაყენეთ პოზიციონირება ყუთისთვის. აქ ყველა მნიშვნელობა არ არის მითითებული პირდაპირ, არამედ მათემატიკური გამონათქვამების დახმარებით, რაც, ფაქტობრივად, არის "სითხის განლაგების" ანალოგი ვებ განვითარებაში. პრობლემა ის არის, რომ GUI ელემენტების ზუსტი ზომების დაზუსტებისას ეკრანის სხვადასხვა რეზოლუციით, ისინი არ ადაპტირდებიან და შეიძლება იყოს ძალიან მცირე ან, პირიქით, დიდი. ძრავის შემდეგ ვერსიაში დეველოპერები გვპირდებიან, რომ GUI-ს ადაპტირებენ, მაგრამ ჯერჯერობით გარყვნილება გვიწევს :(

წარმატების გზაზე ბოლო ნაბიჯი ჩვენი კანის მორგება იქნება. ჩვენ სკრიპტის ცვლადში ვაზუსტებთ skin ფაილს და შემდეგ ვირჩევთ ამ ფაილს პროექტის ფანჯარაში. სხვა ფაილების მსგავსად, კანის პარამეტრები გამოჩნდება ინსპექტორის ფანჯარაში. აქ ჩვენ ვეძებთ ელემენტს, რომელიც ექვემდებარება ცვლილებას (ჩვენს შემთხვევაში, Box), გავხსნათ და დავაყენოთ ისე, როგორც ზემოთ განხილული სტილი:

იმისათვის, რომ დავინახოთ, მუშაობს თუ არა ჩვენი სკრიპტი სწორად, მოდით გავუშვათ პროექტი და შევეცადოთ დააჭიროთ დახმარების ღილაკს:

ახლა ყველაფერი მუშაობს, მაგრამ ყოველთვის არ არის მოსახერხებელი დახმარების ღილაკის დაჭერა აღწერილობის უკან დასამალად. უფრო ჩვეულებრივია ნებისმიერი შეტყობინებების ჩასმა ნებისმიერში თავისუფალი ადგილივიდრე ღილაკებისკენ დამიზნება. და აქ უბრალოდ უნდა გამოვიყენოთ ის ფაქტი, რომ ჩვენ სტატიკური გავხადეთ "isVisible" ცვლადი, ისევე როგორც კოლაიდერი ჩამოკიდებული ფონის სურათზე...

მოდით დავუბრუნდეთ ჩვენს პირველ სკრიპტს ("ხმები"), რომელიც თვალყურს ადევნებდა ღილაკებს ბგერების დასაკრავად. ჩვენთვის საკმარისი იქნება მასში მხოლოდ ერთი სტრიქონის ჩაწერა (უფრო ზუსტად, "void OnMouseDown ()" მეთოდის შიგნით:

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

ამ ხაზით ვაყენებთ პირობას: თუ დაჭერილი კოლაიდერის სახელი არ უტოლდება დახმარების ღილაკის სახელს, მაშინ ცვლადი "isVisible" "Help" სკრიპტში იქნება ტოლი "false". მხოლოდ აუცილებელია, რომ ცვლადს "isVisible" აუცილებლად ჰქონდეს პოსტსკრიპტი "static", წინააღმდეგ შემთხვევაში მივიღებთ შეცდომას.

ახლა, გაშვებისას, დავინახავთ, რომ ჩვენი დახმარების ფანჯარა დახურულია არა მხოლოდ ღილაკზე ზედა მარჯვენა კუთხეში დაჭერისას, არამედ ეკრანის ნებისმიერ თავისუფალ ნაწილზე შეხებისას. ერთადერთი, რაც შეიძლება გაუმჯობესდეს, არის ფანჯრის დამალვა მასზე დაწკაპუნებისას... ეს იქნება თქვენი "საშინაო დავალება";) მხოლოდ იმის თქმა შემიძლია, რომ GUI ყუთი უნდა შეიცვალოს მსგავსი დიზაინის ღილაკზე, ისევ , სკინგის პარამეტრით და ფუნქციის დაწესებით, რომელიც ცვლის "isVisible" ცვლადს. ყველაფერი, გაჩუმდი :)

თამაშის შედგენა და პროექტის შენახვა

საბოლოოდ, ყველაფერი მუშაობს ჩვენთვის! ეს ნიშნავს, რომ დროა შეინახოთ ჩვენი თამაში და შეამოწმოთ იგი რეალურ მოწყობილობაზე. და ამისათვის საჭიროა მისი შედგენა შესრულებად ფაილში (Windows-ისთვის, მაგალითად, EXE-ში და Android-ისთვის, APK-ში).

თუ გსურთ შეადგინოთ თამაში კომპიუტერისთვის, მაშინ არ გჭირდებათ წინასწარი პარამეტრების გაკეთება. თუმცა, Android-ისთვის ჯერ დაგჭირდებათ Android SDK-ის დაკავშირება, რომელიც თავიდანვე გადმოვწერეთ. ეს კეთდება საკმაოდ მარტივად: გადადით მენიუში "რედაქტირება", დარეკეთ "Preferences" პუნქტს და ფანჯარაში, რომელიც იხსნება, გადადით "გარე ხელსაწყოების" ჩანართზე. აქ ჩვენ ვეძებთ ხაზს "Android SDK Location" და მასში მივუთითებთ SDK-ით შეუფუთავი არქივისკენ მიმავალ გზას (იხილეთ ეკრანის სურათი ქვემოთ). სხვათა შორის, აქ ასევე შეგიძლიათ შეცვალოთ ამაზრზენი MonoDevelop ტექსტური რედაქტორი ნაგულისხმევად აქტიური თქვენს საყვარელზე :)

ახლა კი სიმართლის მომენტი დადგა! გადადით "ფაილი" მენიუში და მოძებნეთ იქ "Build Settings" პუნქტი. ფანჯარაში, რომელიც იხსნება, ჩვენ დაუყოვნებლივ უნდა დავამატოთ სცენები შეკრებისთვის. თუ არის მხოლოდ ერთი სცენა (როგორც ჩვენს პროექტში), მაშინ საკმარისი იქნება ღილაკზე "მიამატეთ მიმდინარე" დააჭიროთ. თუ მათგან რამდენიმეა, მაშინ მოგიწევთ თითოეული მათგანის გახსნა და იმავე გზით დამატება სცენების სიაში, შემდეგ კი, გადათრევით და ჩაშვებით, დაარეგულირეთ სასურველი თანმიმდევრობა:

შემდეგი ნაბიჯი არის build პლატფორმის არჩევა (ჩვენ ვგეგმავთ თამაშს Android-ისთვის, რაც იმას ნიშნავს, რომ ჩვენ ვირჩევთ მას) და დააწკაპუნეთ ღილაკზე "მოთამაშის პარამეტრები" ქვემოთ. ინსპექტორის ფანჯარა გაიხსნება რამდენიმე პარამეტრი, რომელთაგან ზოგიერთი სავალდებულო ან ძალიან სასურველია. სასურველია მიუთითოთ დეველოპერი კომპანიის სახელები, პროგრამა და მისი ხატულა (კომპანიის სახელი, პროდუქტის სახელი და ნაგულისხმევი ხატულა, შესაბამისად) პარამეტრების სიის ზედა ნაწილში.

ბოლოში, "სხვა პარამეტრების" განყოფილებაში არის ორი საჭირო პარამეტრი: "Bundle Identifier" და "Bundle Version". ნაგულისხმევი ვერსია დაყენებულია როგორც 1.0, მაგრამ იდენტიფიკატორი უნდა შეიქმნას ხელით და, სასურველია, უნიკალური. ის უნდა შედგებოდეს სამი ნაწილისგან, ერთმანეთისგან წერტილებით გამოყოფილი: დაჯავშნილი სიტყვა "com", შემდეგ დეველოპერი კომპანიის სახელი და ბოლოს თავად აპლიკაციის სახელი.

თქვენ შეგიძლიათ შეცვალოთ დანარჩენი ასამბლეის პარამეტრები თქვენი შეხედულებისამებრ ან საერთოდ არ შეცვალოთ. მთავარი ის არის, რომ ახლა შედგენა უკვე შეძლებს დაიწყოს. ამისათვის უბრალოდ დააწკაპუნეთ ღილაკზე "Build" "Build Settings" ფანჯარაში და დაელოდეთ სანამ პროგრამა მოგვცემს APK ფაილში შეფუთულ მზა აპლიკაციას :)

დასკვნა

ამით დასრულდა ჩვენი გაკვეთილი-მიმოხილვა Android-ისთვის უმარტივესი აპლიკაციების შექმნის შესახებ. იმისათვის, რომ გაიმეოროთ ყველაფერი, რაზეც ვისაუბრეთ, სტატიის ბოლოს მივცემ არქივის ბმულს, რომელიც ინახავს თამაშის ყველა რესურსს ცალკე საქაღალდედ (თუ გსურთ ყველაფერი ნულიდან გააკეთოთ) და როგორც ფაილი unitypackage გაფართოებით. ეს უკანასკნელი საშუალებას გაძლევთ ერთდროულად შემოიტანოთ მთელი პროექტი Unity-ში, მათ შორის დამოკიდებულებები და ა.შ.

ჩვენი პროექტის იმპორტისთვის (და, სხვათა შორის, ინტერნეტიდან ან აქტივების მაღაზიიდან ჩამოტვირთული ნებისმიერი დანამატი), თქვენ უნდა გადახვიდეთ მენიუში "აქტივები", შეარჩიოთ პუნქტი "იმპორტის პაკეტი" და მასში "მორგებული პაკეტი", შემდეგ მიუთითეთ ჩვენი ფაილის გზა და დააჭირეთ ღილაკს "იმპორტი". სხვათა შორის, თქვენ შეგიძლიათ გააკეთოთ თქვენი პროექტის სრული სარეზერვო ასლი, შეინახოთ იგი ასეთ ერთიან პაკეტში, იმავე მენიუდან ("აქტივები") "Export Package" პუნქტზე დაწკაპუნებით.

როგორც ჩანს, ყველაფერი :), როგორც ადამიანი, რომელიც თავად დაეუფლა Unity 3D-ს ნულიდან, სტატიაში შევეცადე პასუხის გაცემა კითხვებზე მაქსიმალურ რაოდენობაზე და ავღნიშნო ძრავთან მუშაობის ძირითადი ნიუანსი, რომელიც წარმოიქმნება თავიდან. მაგრამ, ალბათ, ეს არ იქნება საკმარისი ვინმესთვის, ამიტომ, თუ თქვენ გაქვთ რაიმე შეკითხვები, შეგიძლიათ დამიკავშირდეთ პირდაპირ ფოსტით ან ფორუმზე: მე დაგეხმარებით, როგორც შემიძლია!

გისურვებთ წარმატებებს და ყველა პროექტის წარმატებულ განხორციელებას!

P.S. ნებადართულია ამ სტატიის თავისუფლად კოპირება და ციტირება, იმ პირობით, რომ მითითებულია წყაროს ღია აქტიური ბმული და დაცულია რუსლან ტერტიშნის ავტორობა.