ანდროიდის ერთიანობისთვის 3D თამაშის შექმნა. თამაშის შექმნა Android-ზე. რა არის თამაშის დიზაინერი

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

Android-ის განვითარების გარემოს მომზადება

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

Android-ის ფუნქციებზე წვდომა

Unity უზრუნველყოფს API-ს Android-ის შეყვანაზე და პარამეტრებზე წვდომისთვის. ხელმისაწვდომი კლასები დოკუმენტირებულია Android-ის ასამბლეის კოდის გვერდზე.

C, C++ ან Java კოდის დაკავშირება სკრიპტებთან

Unity გაძლევთ C/C++-ში დაწერილი ფუნქციების გამოძახების საშუალებას პირდაპირ სკრიპტებიდან (Java ფუნქციები შეიძლება დარეკოთ ირიბად). იმის გასაგებად, თუ როგორ შეხვიდეთ Unity-დან მშობლიური კოდიდან ფუნქციებზე, ეწვიეთ Android მოდულის მშენებლობის გვერდს.

ოკლუზიური ამოკვეთა (უხილავი გეომეტრიის ამოკვეთა)

Unity უზრუნველყოფს ოკლუზიის მოცილების მხარდაჭერას, რაც ძალიან სასარგებლოა მობილური პლატფორმებისთვის ოპტიმიზაციისას. Მეტი ინფორმაციაშეგიძლიათ იხილოთ Occlusion cullling გვერდზე.

გაშვების ეკრანის მორგება

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

პრობლემების მოგვარება და შეცდომის შესახებ შეტყობინება

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

როგორ განსხვავდება Unity Android-ისთვის დესკტოპის ვერსიისგან

JavaScript ძლიერი აკრეფით

Unity-ის Android ვერსიის მუშაობის გასაუმჯობესებლად, JavaScript-ში დინამიური აკრეფა ყოველთვის გამორთულია (თითქოს #pragma αυστηρა ავტომატურად გამოიყენება თითოეულ სკრიპტზე). მნიშვნელოვანია გვახსოვდეს, თუ თქვენ ახორციელებთ პროექტს ანდროიდზე ძველი პლატფორმებიდან და თუ შეგხვდებათ შეცდომის შედგენა, პრობლემა პირველ რიგში უნდა მოძებნოთ აკრეფისას. ასეთ შეცდომებთან გამკლავება, როგორც წესი, ადვილია იმით, რომ დარწმუნდებით, რომ ყველა ცვლადის ტიპები აშკარად არის მითითებული ან ინიციალიზაციის დროს.

მიუხედავად იმისა, რომ Unity Android მხარს უჭერს DXT/PVRTC/ATC ტექსტურებს, Unity დეკომპრესირებს ტექსტურებს RGB(A) ფორმატში მუშაობის დროს, თუ შეკუმშვის ეს მეთოდები არ არის მხარდაჭერილი კონკრეტულ მოწყობილობაზე. ამან შეიძლება სერიოზულად იმოქმედოს GPU-ს რენდერის მუშაობაზე, ამიტომ რეკომენდებულია ETC ფორმატის გამოყენება. ეს არის Android-ის დე ფაქტო სტანდარტი და უნდა იყოს მხარდაჭერილი ყველა თანამედროვე მოწყობილობის მიერ. მეორეს მხრივ, ETC არ უჭერს მხარს ალფა არხს და ზოგჯერ 16-ბიტიანი RGBA ტექსტურები საუკეთესო არჩევანი იქნება ხარისხის, ზომისა და გადაცემის სიჩქარის თვალსაზრისით, სადაც საჭიროა ალფა არხი.

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

Unity 3D-ში შექმნილი მზა პროდუქტები თავსებადია თითქმის ყველა პოპულარულ პლატფორმასთან - დაწყებული მობილური ტელეფონებიდა დამთავრებული SMART ტელევიზორით.

პროგრამის მახასიათებლები:

  • სასწავლო ძრავა Unity;
  • მოქნილი მრავალფუნქციური რედაქტორი;
  • შედგენის მაღალი სიჩქარე;
  • ადვილად შესასწავლი ინტერფეისი;
  • თავსებადობა პლატფორმების დიდ რაოდენობასთან.

მოქმედების პრინციპი

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

უფასო ვერსიის გარდა, შეგიძლიათ გამოიწეროთ ორი სხვა გაფართოებული ვერსია:

Unity Plus (~$25 თვეში) - უზრუნველყოფს შეზღუდული წვდომას მომხმარებელთა წარმატების მრჩეველის სერვისზე, აგროვებს ინფორმაციას მომხმარებლის მოწყობილობებზე წარუმატებლობის შესახებ, აკონტროლებს გამოხმაურებას.

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

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

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

აღსანიშნავია, რომ 3D გრაფიკასთან მუშაობისთვის საჭიროა გქონდეთ თანამედროვე კომპიუტერი ტექნიკის ვიდეო ბარათით.

Დადებითი:

  • თითქმის შეუზღუდავი ფუნქციონირება პროექტების შესაქმნელად;
  • ბრაუზერზე დაფუძნებული 3D გრაფიკის მხარდაჭერა;
  • თავსებადი სათამაშო კონსოლებიდა თანამედროვე ტელევიზორები;
  • ვიზუალიზაციის ხელსაწყოების დიდი რაოდენობა;
  • არის უფასო ვერსია.

მინუსები:

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

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

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

ანალოგები:

  • თამაშის რედაქტორი - უფასო აპლიკაციათამაშების შექმნა;
  • Construct 2 არის პოპულარული თამაშის კონსტრუქტორი მარტივი ინტერფეისით.
  • Construct 2 არის ძლიერი პროგრამა 2D პროექტების შესაქმნელად.

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

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

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

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

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


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

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

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

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

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


ასევე შექმენით მთები და მუწუკები. შემდეგ ჩატვირთეთ 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-ისთვის და ისწავლოთ როგორ დაწეროთ სკრიპტები თავად.

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

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

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

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

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

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

მსგავსი პოსტები