DevOps C++ და „სამზარეულო ომები“, ან როგორ დავიწყე თამაშების წერა ჭამის დროს

"მე ვიცი, რომ არაფერი ვიცი" სოკრატე

ვისთვის: IT ადამიანებისთვის, რომლებსაც არ აინტერესებთ ყველა დეველოპერი და სურთ მათი თამაშების თამაში!

Რის შესახებ: იმის შესახებ, თუ როგორ უნდა დაიწყოთ თამაშების წერა C/C++-ში, თუ ეს მოულოდნელად დაგჭირდათ!

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

გამარჯობა, ჩემი სახელია ანდრეი გრანკინიმე ვარ DevOps Luxoft-ში. აპლიკაციის შემუშავება არ არის ჩემი სპეციალობა, მაგრამ ყოველ კვირა ვცდილობ კოდირებას. იმიტომ რომ მე მიყვარს თამაშები!

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

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

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

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

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

პრაქტიკა

"ცოდნა პრაქტიკის გარეშე უსარგებლოა, პრაქტიკა ცოდნის გარეშე საშიშია" კონფუცი

ჩემი ბლოკნოტი ჩემი ცხოვრებაა!

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

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

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

• პროექტი 0: ეს არის 3D Architect-ის დემო სცენა დაწერილი C#-ში Unity თამაშის ძრავის გამოყენებით. macOS და Windows პლატფორმებისთვის.
• თამაში 1: კონსოლის თამაში Simple Snake (ყველასთვის ცნობილია როგორც "Snake") Windows-ისთვის. დაწერილი C.
• თამაში 2: კონსოლის თამაში Crazy Tanks (ყველასთვის ცნობილი როგორც "Tanks"), დაწერილი C++ (კლასების გამოყენებით) და ასევე Windows-ისთვის.

პროექტი 0. Architect Demo

• პლატფორმა: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• ენა: C#
• თამაშის ძრავა: Unity
• Შთაგონების: დარინ ლილე
• საცავი: GitHub

3D სცენის არქიტექტორის დემო

პირველი პროექტი განხორციელდა არა C/C++, არამედ C#-ში Unity თამაშის ძრავის გამოყენებით. ეს ძრავა არ იყო ისეთი მოთხოვნადი აპარატურაზე, როგორც არარეალური ძრავადა ასევე უფრო ადვილი ჩანდა ინსტალაცია და გამოყენება. სხვა ძრავები არ განვიხილე.

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

დავიწყე YouTube-ზე სამეურვეო ვიდეოებით 3D მოდელების შექმნის შესახებ Blender. ბლენდერი არის შესანიშნავი უფასო ინსტრუმენტი 3D მოდელირებისთვის (და მეტი), რომელიც არ საჭიროებს ინსტალაციას. აქ კი შოკი მელოდა... თურმე მოდელირება, ანიმაცია, ტექსტურირება უზარმაზარი ცალკე თემებია, რომლებზეც შეიძლება წიგნების დაწერა. ეს განსაკუთრებით ეხება პერსონაჟებს. თითების, კბილების, თვალების და სხეულის სხვა ნაწილების მოდელირებისთვის, დაგჭირდებათ ანატომიის ცოდნა. როგორ არის აგებული სახის კუნთები? როგორ მოძრაობენ ადამიანები? ძვლების „ჩასმა“ მომიწია თითოეულ მკლავში, ფეხში, თითში, თითების ფალანგებში!

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

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

წრეზე და სფეროზე წერტილის კოორდინატების გამოსათვლელად ფორმულების გაანგარიშება (ჩემი რვეულიდან)

თამაში 1. მარტივი გველი

• პლატფორმა: Windows (დატესტილია Windows 7, 10-ზე)
• ენა: მგონი სუფთა C-ით დავწერე
• თამაშის ძრავა: Windows კონსოლი
• Შთაგონების: javidx9
• საცავი: GitHub

მარტივი გველის თამაში

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

რა არის მარტივი და სწრაფი? მართალია, კონსოლი და 2D. უფრო ზუსტად კი კონსოლი და სიმბოლოები. ისევ წავედი ინტერნეტში ინსპირაციის საძიებლად (ზოგადად, ვფიქრობ, ინტერნეტი XNUMX-ე საუკუნის ყველაზე რევოლუციური და საშიში გამოგონებაა). მე ამოვთხარე პროგრამისტის ვიდეო, რომელმაც კონსოლი Tetris შექმნა. და მისი თამაშის მსგავსად მე გადავწყვიტე "გველი" გამეკეთებინა. ვიდეოდან გავიგე ორი ფუნდამენტური რამ - თამაშის ციკლი (სამი ძირითადი ფუნქციით/ნაწილით) და ბუფერში გამომავალი.

თამაშის ციკლი შეიძლება ასე გამოიყურებოდეს:

int main()
   {
      Setup();
      // a game loop
      while (!quit)
      {
          Input();
          Logic();
          Draw();
          Sleep(gameSpeed);  // game timing
      }
      return 0;
   }

კოდი ერთდროულად წარმოადგენს მთელ main() ფუნქციას. და თამაშის ციკლი იწყება შესაბამისი კომენტარის შემდეგ. მარყუჟში სამი ძირითადი ფუნქციაა: Input(), Logic(), Draw(). ჯერ შეიტანეთ მონაცემების შეყვანა (ძირითადად კლავიშების კონტროლი), შემდეგ შეყვანილი მონაცემების Logic დამუშავება, შემდეგ ეკრანზე გამოტანა - Draw. და ასე შემდეგ ყველა ჩარჩო. ასე იქმნება ანიმაცია. როგორც მულტფილმებშია. როგორც წესი, შეყვანილი მონაცემების დამუშავებას ყველაზე მეტი დრო სჭირდება და, როგორც ვიცი, განსაზღვრავს თამაშის კადრების სიხშირეს. მაგრამ აქ Logic() ფუნქცია ძალიან სწრაფად სრულდება. ამიტომ, თქვენ უნდა აკონტროლოთ კადრების სიხშირე Sleep() ფუნქციის გამოყენებით gameSpeed ​​პარამეტრით, რომელიც განსაზღვრავს ამ სიჩქარეს.

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

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

ეკრანის ბუფერის მიღება (ასე ვთქვათ):

// create screen buffer for drawings
   HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
 							   NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
   DWORD dwBytesWritten = 0;
   SetConsoleActiveScreenBuffer(hConsole);

გარკვეული სტრიქონის ქულების ხაზის პირდაპირი ჩვენება (ქულების ჩვენების ხაზი):

// draw the score
   WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);

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

თამაში 2. Crazy Tanks

• პლატფორმა: Windows (დატესტილია Windows 7, 10-ზე)
• ენა: C + +
• თამაშის ძრავა: Windows კონსოლი
• Შთაგონების: книга C++-ის დაწყება თამაშის პროგრამირების საშუალებით
• საცავი: GitHub

თამაშის Crazy Tanks

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

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

ასე რომ, რასაც ხედავთ ეკრანზე არის მხოლოდ მოძრავი მრავალფერადი მართკუთხედების ნაკრები.

მართკუთხედების ნაკრები

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

თამაშის სატანკო მატრიცის მაგალითი

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

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

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

ერთგანზომილებიანი მასივის გავლა ორმაგ მარყუჟში. Y - მწკრივის იდენტიფიკატორი, X - სვეტის იდენტიფიკატორი

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

ახლა პიქსელების, ფერის და ეკრანის გამომუშავების შესახებ. გამოსასვლელად გამოიყენება StretchDIBits ფუნქცია (Header: windows.h; Library: gdi32.lib). ეს ფუნქცია, სხვა საკითხებთან ერთად, იღებს შემდეგს: მოწყობილობას, რომელზეც გამოსახულია გამოსახულება (ჩემს შემთხვევაში ეს არის Windows კონსოლი), გამოსახულების ჩვენების საწყისი კოორდინატები, მისი სიგანე/სიმაღლე და თავად სურათი bitmap-ის ფორმა, რომელიც წარმოდგენილია ბაიტების მასივით. Bitmap როგორც ბაიტის მასივი!

StretchDIBits() ფუნქცია მოქმედებაში:

// screen output for game field
   StretchDIBits(
               deviceContext,
               OFFSET_LEFT, OFFSET_TOP,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               0, 0,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               m_p_bitmapMemory, &bitmapInfo,
               DIB_RGB_COLORS,
               SRCCOPY
               );

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

m_p_bitmapმეხსიერების ბიტმაპის შექმნა:

// create bitmap
   int bitmapMemorySize = (PMATRIX_WIDTH * PMATRIX_HEIGHT) * BYTES_PER_PIXEL;
   void* m_p_bitmapMemory = VirtualAlloc(0, bitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);

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

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

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

ბიტმაპის (Pixel matrix) შევსების მაგალითი სათამაშო მოედნის ციფრულ მატრიცაზე დაფუძნებული ინფორმაციით (ფერების ინდექსები არ ემთხვევა თამაშში არსებულ ინდექსებს)

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

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

Bitmap-ის შევსება სათამაშო მოედნის ციფრული მატრიცის საფუძველზე ინფორმაციით:

// set pixel map variables
   int colorIndex;
   COLORREF color;
   int pitch;
   uint8_t* p_row;
 
   // arrange pixels for game field
   pitch = PMATRIX_WIDTH * BYTES_PER_PIXEL;     // row size in bytes
   p_row = (uint8_t*)m_p_bitmapMemory;       //cast to uint8 for valid pointer arithmetic
   							(to add by 1 byte (8 bits) at a time)   
   for (int y = 0; y < PMATRIX_HEIGHT; ++y)
   {
       uint32_t* p_pixel = (uint32_t*)p_row;
       for (int x = 0; x < PMATRIX_WIDTH; ++x)
       {
           colorIndex = mainDigitalMatrix[y * PMATRIX_WIDTH + x];
           color = Utils::GetColor(colorIndex);
           uint8_t blue = GetBValue(color);
           uint8_t green = GetGValue(color);
           uint8_t red = GetRValue(color);
           uint8_t pixelPadding = 0;
 
           *p_pixel = ((pixelPadding << 24) | (red << 16) | (green << 8) | blue);
           ++p_pixel;
       }
       p_row += pitch;
   }

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

თეორიულად (თუ არაფერი დამავიწყდა), პირველი თამაშიდან თამაშის მარყუჟის გაგება („გველი“) და მეორე თამაშიდან ეკრანზე პიქსელების ჩვენების სისტემის („ტანკები“) არის ის, რაც უნდა დაწეროთ. თქვენი 2D თამაშები Windows-ის ქვეშ. უხმოდ! 😉 დანარჩენი ნაწილები მხოლოდ ფანტაზიის ფრენაა.

რა თქმა უნდა, თამაში "ტანკები" ბევრად უფრო რთულია, ვიდრე "გველი". მე უკვე გამოვიყენე C++ ენა, ანუ კლასებით აღვწერე თამაშის სხვადასხვა ობიექტები. მე შევქმენი ჩემი კოლექცია - კოდის ნახვა შესაძლებელია headers/Box.h-ში. სხვათა შორის, კოლექციას დიდი ალბათობით აქვს მეხსიერების გაჟონვა. გამოყენებული მაჩვენებლები. მუშაობდა მეხსიერებით. უნდა ითქვას, რომ წიგნი ძალიან დამეხმარა C++-ის დაწყება თამაშის პროგრამირების საშუალებით. ეს შესანიშნავი დასაწყისია C++-ში დამწყებთათვის. ის არის პატარა, საინტერესო და კარგად ორგანიზებული.

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

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

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

ავზის ღერძის გარშემო ბრუნვის ალგორითმისა და ფორმულების გაანგარიშება

ჩემი კოლექციის სქემა (ის, რომელშიც არის მეხსიერების გაჟონვა, სავარაუდოდ). კოლექცია იქმნება Linked List ტიპის მიხედვით

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

Теория

"ათასი მილის მოგზაურობაც კი იწყება პირველი ნაბიჯით" (ძველი ჩინური სიბრძნე)

გადავიდეთ პრაქტიკიდან თეორიაზე! როგორ გამონახოთ დრო თქვენი ჰობისთვის?

1. განსაზღვრეთ რა გსურთ სინამდვილეში (სამწუხაროდ, ეს ყველაზე რთული ნაწილია).
2. დააყენეთ პრიორიტეტები.
3. შესწირეთ ყველაფერი „ზედმეტი“ უმაღლესი პრიორიტეტების გულისთვის.
4. ყოველდღე იარეთ მიზნებისკენ.
5. ნუ ელით ორ-სამ საათს თავისუფალი დროის გატარებას ჰობიზე.

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

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

და მნიშვნელოვანია გვახსოვდეს, რომ არ უნდა შეაფასოთ და უგულებელყოთ დროის უფასო „ნახერხი“ 5, 10, 15 წუთის განმავლობაში, დაელოდეთ რამდენიმე დიდ „მორს“, რომელიც გრძელდება ერთი ან ორი საათის განმავლობაში. რიგში დგახარ? იფიქრეთ რაიმე თქვენი პროექტისთვის. ესკალატორით მიდიხარ? ჩაწერეთ რამე ბლოკნოტში. ავტობუსით მოგზაურობთ? კარგია, წაიკითხეთ სტატია. ისარგებლეთ ყველა შესაძლებლობით. შეწყვიტე კატებისა და ძაღლების ყურება YouTube-ზე! ნუ აბინძურებ ტვინს!

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

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

წარმატებებს გისურვებთ არჩეულ გზაზე! და მოდით გავხადოთ მსოფლიო უფრო პროფესიონალი.

ავტორი: გრანკინი ანდრეი, DevOps

წყარო: www.habr.com