DevOps C++ និង "សង្រ្គាមផ្ទះបាយ" ឬរបៀបដែលខ្ញុំចាប់ផ្តើមសរសេរហ្គេមពេលកំពុងញ៉ាំ

"ខ្ញុំដឹងថាខ្ញុំមិនដឹងអ្វីទាំងអស់" សូក្រាត

សម្រាប់អ្នកណា៖ សម្រាប់អ្នក IT ដែលស្ដោះទឹកមាត់ដាក់ Developer ទាំងអស់ ហើយចង់លេងហ្គេមរបស់ពួកគេ!

អំពី​អ្វី: របៀបចាប់ផ្តើមសរសេរហ្គេមក្នុង C/C++ ប្រសិនបើអ្នកត្រូវការវា!

ហេតុអ្វីបានជាអ្នកគួរអាននេះ៖ ការអភិវឌ្ឍន៍កម្មវិធីមិនមែនជាជំនាញការងាររបស់ខ្ញុំទេ ប៉ុន្តែខ្ញុំព្យាយាមសរសេរកូដរៀងរាល់សប្តាហ៍។ ព្រោះខ្ញុំស្រលាញ់ហ្គេម!

សួរ​ស្ដី​ឈ្មោះ​របស់ខ្ញុំ​គឺ Andrey Grankinខ្ញុំជា DevOps នៅ Luxoft ។ ការអភិវឌ្ឍន៍កម្មវិធីមិនមែនជាជំនាញការងាររបស់ខ្ញុំទេ ប៉ុន្តែខ្ញុំព្យាយាមសរសេរកូដរៀងរាល់សប្តាហ៍។ ព្រោះខ្ញុំស្រលាញ់ហ្គេម!

ឧស្សាហកម្មហ្គេមកុំព្យូទ័រមានទំហំធំ ថែមទាំងមានពាក្យចចាមអារ៉ាមជាងឧស្សាហកម្មភាពយន្តទៅទៀត។ ហ្គេមត្រូវបានសរសេរតាំងពីការចាប់ផ្តើមនៃការអភិវឌ្ឍន៍កុំព្យូទ័រ ដោយប្រើស្តង់ដារទំនើប វិធីសាស្ត្រអភិវឌ្ឍន៍ស្មុគស្មាញ និងជាមូលដ្ឋាន។ យូរ ៗ ទៅម៉ាស៊ីនហ្គេមបានចាប់ផ្តើមលេចឡើងជាមួយនឹងក្រាហ្វិក រូបវិទ្យា និងសំឡេងដែលបានរៀបចំរួចជាស្រេច។ ពួកគេអនុញ្ញាតឱ្យអ្នកផ្តោតលើការអភិវឌ្ឍន៍ហ្គេមដោយខ្លួនឯងហើយមិនរំខានអំពីមូលដ្ឋានគ្រឹះរបស់វា។ ប៉ុន្តែរួមជាមួយពួកគេជាមួយនឹងម៉ាស៊ីនអ្នកអភិវឌ្ឍន៍ "ងងឹតភ្នែក" និងធ្វើឱ្យខូចគុណភាព។ ការផលិតហ្គេមជាច្រើនត្រូវបានដាក់នៅលើ conveyor ។ ហើយបរិមាណនៃការផលិតចាប់ផ្តើមលើសគុណភាពរបស់វា។

ក្នុងពេលជាមួយគ្នានេះ នៅពេលដែលលេងហ្គេមរបស់អ្នកដ៏ទៃ យើងតែងតែកំណត់ដោយទីតាំង គ្រោង តួអង្គ មេកានិកហ្គេម ដែលមនុស្សផ្សេងទៀតបានបង្កើតឡើង។ ដូច្នេះខ្ញុំបានដឹងថា...

… វាដល់ពេលហើយដើម្បីបង្កើតពិភពលោកផ្ទាល់ខ្លួនរបស់អ្នក ប្រធានបទសម្រាប់តែខ្ញុំប៉ុណ្ណោះ។ ពិភពលោកដែលខ្ញុំជាព្រះវរបិតា ជាព្រះរាជបុត្រា និងព្រះវិញ្ញាណបរិសុទ្ធ!

ហើយខ្ញុំជឿជាក់ដោយស្មោះថា តាមរយៈការសរសេរម៉ាស៊ីនហ្គេមផ្ទាល់ខ្លួនរបស់អ្នក និងហ្គេមនៅលើវា អ្នកនឹងអាចបើកភ្នែករបស់អ្នក ជូតបង្អួច និងបូមកាប៊ីនរបស់អ្នក ក្លាយជាអ្នកសរសេរកម្មវិធីដែលមានបទពិសោធន៍ និងសំខាន់ជាង។

នៅក្នុងអត្ថបទនេះខ្ញុំនឹងព្យាយាមប្រាប់អ្នកពីរបៀបដែលខ្ញុំចាប់ផ្តើមសរសេរហ្គេមតូចៗនៅក្នុង C/C ++ តើអ្វីជាដំណើរការអភិវឌ្ឍន៍ និងកន្លែងដែលខ្ញុំស្វែងរកពេលវេលាសម្រាប់ចំណង់ចំណូលចិត្តក្នុងបរិយាកាសមមាញឹក។ វាជាកម្មវត្ថុ និងពិពណ៌នាអំពីដំណើរការនៃការចាប់ផ្តើមបុគ្គល។ សម្ភារៈអំពីភាពល្ងង់ខ្លៅ និងជំនឿ អំពីរូបភាពផ្ទាល់ខ្លួនរបស់ខ្ញុំអំពីពិភពលោកនៅពេលនេះ។ ម្យ៉ាងទៀត "រដ្ឋបាលមិនទទួលខុសត្រូវចំពោះខួរក្បាលផ្ទាល់ខ្លួនរបស់អ្នកទេ!"។

អនុវត្ត

“ចំណេះដឹងដោយគ្មានការអនុវត្តគឺគ្មានប្រយោជន៍ ការអនុវត្តដោយគ្មានចំណេះដឹងគឺមានគ្រោះថ្នាក់” ខុងជឺ

សៀវភៅកត់ត្រាគឺជាជីវិតរបស់ខ្ញុំ!

ដូច្នេះនៅក្នុងការអនុវត្តខ្ញុំអាចនិយាយបានថាអ្វីគ្រប់យ៉ាងសម្រាប់ខ្ញុំចាប់ផ្តើមជាមួយសៀវភៅកត់ត្រា។ ខ្ញុំសរសេរមិនត្រឹមតែកិច្ចការប្រចាំថ្ងៃរបស់ខ្ញុំនៅទីនោះប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងគូរ កម្មវិធី គំនូសតាងលំហូរ និងដោះស្រាយបញ្ហា រួមទាំងគណិតវិទ្យាផងដែរ។ តែងតែប្រើក្រដាសកត់ចំណាំ ហើយសរសេរតែជាមួយខ្មៅដៃប៉ុណ្ណោះ។ វាស្អាត មានផាសុកភាព និងអាចទុកចិត្តបាន IMHO ។

សៀវភៅកត់ត្រារបស់ខ្ញុំ (បានបំពេញរួចហើយ) ។ នេះជារបៀបដែលវាមើលទៅ។ វាមានភារកិច្ចប្រចាំថ្ងៃ គំនិត គំនូរ ដ្យាក្រាម ដំណោះស្រាយ សៀវភៅបញ្ជីខ្មៅ កូដជាដើម។

នៅដំណាក់កាលនេះ ខ្ញុំបានគ្រប់គ្រងដើម្បីបញ្ចប់គម្រោងចំនួនបី (នេះគឺនៅក្នុងការយល់ដឹងរបស់ខ្ញុំអំពី "ចុងក្រោយ" ពីព្រោះផលិតផលណាមួយអាចត្រូវបានអភិវឌ្ឍដោយមិនចេះចប់)។

• គម្រោងទី ២៖ នេះជាឈុតស្ថាបត្យករ 3D Demo ដែលសរសេរក្នុង C# ដោយប្រើម៉ាស៊ីនហ្គេម Unity។ សម្រាប់វេទិកា macOS និង Windows ។
• ល្បែងទី ១៖ ហ្គេមកុងសូល Simple Snake (ដែលគេស្គាល់ថាជា "ពស់") សម្រាប់វីនដូ។ សរសេរ​ក្នុង C.
• ល្បែងទី ១៖ កុងសូលហ្គេម Crazy Tanks (ដែលគេស្គាល់ថាជា "ធុង") បានសរសេររួចហើយនៅក្នុង C ++ (ប្រើថ្នាក់) និងនៅក្រោម Windows ផងដែរ។

គម្រោង 0 ស្ថាបត្យករ Demo

• វេទិកា៖ Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• Язык: C#
• ម៉ាស៊ីនហ្គេម៖ ការយូនីធី
• ការបំផុសគំនិត៖ ដារិន លី
• ឃ្លាំង៖ GitHub

ការបង្ហាញស្ថាបត្យករ 3D Scene

គម្រោងទីមួយត្រូវបានអនុវត្តមិនមែននៅក្នុង C/C++ ទេ ប៉ុន្តែនៅក្នុង C# ដោយប្រើម៉ាស៊ីនហ្គេម Unity ។ ម៉ាស៊ីននេះមិនមានតម្រូវការលើផ្នែករឹងដូចនោះទេ។ មិនពិតម៉ាស៊ីនហើយវាក៏ហាក់ដូចជាខ្ញុំងាយស្រួលដំឡើង និងប្រើប្រាស់ផងដែរ។ ខ្ញុំមិនបានពិចារណាម៉ាស៊ីនផ្សេងទៀតទេ។

គោលដៅនៅក្នុង Unity សម្រាប់ខ្ញុំគឺមិនមែនដើម្បីអភិវឌ្ឍប្រភេទហ្គេមមួយចំនួននោះទេ។ ខ្ញុំចង់បង្កើតឈុត 3D ដែលមានតួអក្សរប្រភេទខ្លះ គាត់ ឬនាង (ខ្ញុំបានយកគំរូតាមនារីដែលខ្ញុំស្រលាញ់ =) ត្រូវផ្លាស់ទី និងទំនាក់ទំនងជាមួយពិភពខាងក្រៅ។ វាមានសារៈសំខាន់តែក្នុងការយល់ដឹងថាតើ Unity ជាអ្វី ដំណើរការអភិវឌ្ឍន៍គឺជាអ្វី និងថាតើវាត្រូវការការខិតខំប្រឹងប្រែងប៉ុន្មានដើម្បីបង្កើតអ្វីមួយ។ នេះជារបៀបដែលគម្រោងស្ថាបត្យករ Demo បានកើត (ឈ្មោះត្រូវបានបង្កើតឡើងស្ទើរតែពីរឿងអាស្រូវ) ។ ការសរសេរកម្មវិធី ការធ្វើគំរូ គំនូរជីវចល វាយនភាព បានធ្វើឱ្យខ្ញុំប្រហែលពីរខែនៃការងារប្រចាំថ្ងៃ។

ខ្ញុំបានចាប់ផ្តើមជាមួយនឹងវីដេអូបង្រៀននៅលើ YouTube អំពីរបៀបបង្កើតគំរូ 3D នៅក្នុង កម្មវិធីលាយ. Blender គឺជាឧបករណ៍ឥតគិតថ្លៃដ៏អស្ចារ្យសម្រាប់ការធ្វើគំរូ 3D (និងច្រើនទៀត) ដែលមិនត្រូវការការដំឡើង។ ហើយនៅទីនេះភាពតក់ស្លុតកំពុងរង់ចាំខ្ញុំ ... វាប្រែថាការធ្វើគំរូ គំនូរជីវចល វាយនភាព គឺជាប្រធានបទដាច់ដោយឡែកដ៏ធំដែលអ្នកអាចសរសេរសៀវភៅបាន។ នេះជាការពិតជាពិសេសសម្រាប់តួអង្គ។ ដើម្បីយកគំរូតាមម្រាមដៃ ធ្មេញ ភ្នែក និងផ្នែកផ្សេងទៀតនៃរាងកាយ អ្នកនឹងត្រូវការចំណេះដឹងអំពីកាយវិភាគសាស្ត្រ។ តើសាច់ដុំមុខត្រូវបានរៀបចំយ៉ាងដូចម្តេច? តើមនុស្សផ្លាស់ទីដោយរបៀបណា? ខ្ញុំត្រូវ "បញ្ចូល" ឆ្អឹងទៅក្នុងដៃ ជើង ម្រាមដៃ កែងដៃ!

យកគំរូតាម clavicle, levers ឆ្អឹងបន្ថែម ដើម្បីឱ្យចលនាមើលទៅធម្មជាតិ។ បន្ទាប់ពីមេរៀនបែបនេះ អ្នកដឹងពីការងារដ៏ធំដែលអ្នកបង្កើតភាពយន្តគំនូរជីវចលធ្វើ ដោយគ្រាន់តែបង្កើតវីដេអូរយៈពេល 30 វិនាទីប៉ុណ្ណោះ។ ប៉ុន្តែភាពយន្ត 3D មានរយៈពេលរាប់ម៉ោង! ហើយ​បន្ទាប់​មក យើង​ចេញ​ពី​រោង​ភាពយន្ត ហើយ​និយាយ​រឿង​មួយ​ដូច​ជា៖ “តា រូប​ថ្លុក/ភាពយន្ត​ដ៏​អាក្រក់! ពួកគេអាចធ្វើបានល្អជាងនេះ…” មនុស្សល្ងីល្ងើ!

ហើយរឿងមួយទៀតអំពីការសរសេរកម្មវិធីនៅក្នុងគម្រោងនេះ។ ដូចដែលវាបានប្រែក្លាយផ្នែកដែលគួរឱ្យចាប់អារម្មណ៍បំផុតសម្រាប់ខ្ញុំគឺគណិតវិទ្យា។ ប្រសិនបើអ្នកដំណើរការកន្លែងកើតហេតុ (តំណភ្ជាប់ទៅឃ្លាំងនៅក្នុងការពិពណ៌នាគម្រោង) អ្នកនឹងសម្គាល់ឃើញថាកាមេរ៉ាបង្វិលជុំវិញតួស្រីក្នុងរង្វង់មួយ។ ដើម្បី​រៀបចំ​ការ​បង្វិល​កាមេរ៉ា​បែប​នេះ ដំបូង​ខ្ញុំ​ត្រូវ​គណនា​កូអរដោនេ​នៃ​ចំណុច​ទីតាំង​នៅ​លើ​រង្វង់ (2D) ហើយ​បន្ទាប់​មក​នៅ​លើ​ស្វ៊ែរ (3D)។ អ្វី​ដែល​គួរ​ឱ្យ​អស់​សំណើច​នោះ​គឺ​ថា ខ្ញុំ​ស្អប់​គណិតវិទ្យា​នៅ​សាលា ហើយ​ស្គាល់​វា​ដោយ​ដក។ មួយផ្នែក ប្រហែលជាដោយសារតែនៅសាលា ពួកគេគ្រាន់តែមិនពន្យល់អ្នកពីរបៀបដែលគណិតវិទ្យានេះត្រូវបានអនុវត្តនៅក្នុងជីវិត។ ប៉ុន្តែ​ពេល​ដែល​អ្នក​ឈ្លក់​វង្វេង​នឹង​គោលដៅ​របស់​អ្នក ក្តី​សុបិន​នោះ​ចិត្ត​ក៏​បាន​ស្រឡះ​ចេញ​វិញ​ហើយ! ហើយ​អ្នក​ចាប់​ផ្ដើម​យល់​ថា​កិច្ចការ​ស្មុគស្មាញ​ជា​ដំណើរ​ផ្សងព្រេង​ដ៏​រំភើប។ ហើយ​បន្ទាប់​មក​អ្នក​គិត​ថា​៖ "មែន​ហើយ ហេតុ​អ្វី​បាន​ជា​អ្នក​គណិត​វិទ្យា​ដែល​ជា​ទី​ស្រឡាញ់* មិន​អាច​ប្រាប់​ពី​កន្លែង​ដែល​រូបមន្ត​ទាំង​នេះ​អាច​ត្រូវ​បាន​គេ​ផ្អៀង?

ការគណនារូបមន្តសម្រាប់គណនាកូអរដោនេនៃចំណុចមួយនៅលើរង្វង់មួយ និងនៅលើស្វ៊ែរ (ពីសៀវភៅកត់ត្រារបស់ខ្ញុំ)

ហ្គេម 1

• វេទិកា៖ Windows (សាកល្បងលើ Windows 7, 10)
• Язык: ខ្ញុំគិតថាវាត្រូវបានសរសេរជា C
• ម៉ាស៊ីនហ្គេម៖ កុងសូលវីនដូ
• ការបំផុសគំនិត៖ 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() លឿនណាស់។ ដូច្នេះ អត្រាស៊ុមត្រូវតែត្រូវបានគ្រប់គ្រងដោយមុខងារ Sleep() ជាមួយនឹងប៉ារ៉ាម៉ែត្រ gameSpeed ​​​​ដែលកំណត់អត្រានេះ។

វដ្តហ្គេម។ ការសរសេរកម្មវិធីពស់នៅក្នុង notepad

ប្រសិនបើអ្នកកំពុងបង្កើតហ្គេមកុងសូលនិមិត្តសញ្ញា នោះការបង្ហាញទិន្នន័យនៅលើអេក្រង់ដោយប្រើទិន្នផលស្ទ្រីមធម្មតា '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 ++
• ម៉ាស៊ីនហ្គេម៖ កុងសូលវីនដូ
• ការបំផុសគំនិត៖ សៀវភៅ ចាប់ផ្តើម C++ តាមរយៈកម្មវិធីហ្គេម
• ឃ្លាំង៖ GitHub

ហ្គេម Crazy Tanks

ការបោះពុម្ពតួអក្សរទៅកុងសូលគឺប្រហែលជារឿងសាមញ្ញបំផុតដែលអ្នកអាចប្រែក្លាយទៅជាហ្គេម។ ប៉ុន្តែបន្ទាប់មកបញ្ហាមួយលេចឡើង: តួអក្សរមានកម្ពស់និងទទឹងខុសគ្នា (កម្ពស់គឺធំជាងទទឹង) ។ ដូច្នេះ អ្វីៗនឹងមើលទៅមិនសមាមាត្រ ហើយការរំកិលចុះក្រោម ឬឡើងលើហាក់ដូចជាលឿនជាងការផ្លាស់ទីទៅឆ្វេង ឬស្តាំ។ ឥទ្ធិពលនេះគឺគួរឱ្យកត់សម្គាល់នៅក្នុង "ពស់" (ហ្គេម 1) ។ "ធុង" (ហ្គេមទី 2) មិនមានគុណវិបត្តិបែបនេះទេព្រោះលទ្ធផលនៅទីនោះត្រូវបានរៀបចំដោយការគូរភីកសែលអេក្រង់ជាមួយនឹងពណ៌ផ្សេងគ្នា។ អ្នក​អាច​និយាយ​ថា​ខ្ញុំ​បាន​សរសេរ renderer ។ ពិត នេះ​គឺ​ជា​ការ​ស្មុគស្មាញ​បន្តិច​រួច​ទៅ​ហើយ ទោះ​បី​ជា​គួរ​ឱ្យ​ចាប់​អារម្មណ៍​ជាង​នេះ​ក៏​ដោយ។

សម្រាប់ហ្គេមនេះ វានឹងគ្រប់គ្រាន់ដើម្បីពិពណ៌នាអំពីប្រព័ន្ធរបស់ខ្ញុំសម្រាប់បង្ហាញភីកសែលនៅលើអេក្រង់។ ខ្ញុំគិតថានេះគឺជាផ្នែកសំខាន់នៃហ្គេម។ ហើយអ្វីផ្សេងទៀតដែលអ្នកអាចមកជាមួយខ្លួនអ្នក។

ដូច្នេះ អ្វីដែលអ្នកឃើញនៅលើអេក្រង់គឺគ្រាន់តែជាសំណុំនៃចតុកោណពណ៌ដែលផ្លាស់ទីប៉ុណ្ណោះ។

កំណត់ចតុកោណ

ចតុកោណកែងនីមួយៗត្រូវបានតំណាងដោយម៉ាទ្រីសដែលបំពេញដោយលេខ។ និយាយអីញ្ចឹង ខ្ញុំអាចរំលេចចំណុចគួរឱ្យចាប់អារម្មណ៍មួយ - ម៉ាទ្រីសទាំងអស់នៅក្នុងហ្គេមត្រូវបានសរសេរកម្មវិធីជាអារេមួយវិមាត្រ។ មិន​មែន​ពីរ​វិមាត្រ​ទេ​គឺ​មួយ​វិមាត្រ​! អារេមួយវិមាត្រមានភាពងាយស្រួល និងលឿនជាងមុនក្នុងការធ្វើការជាមួយ។

ឧទាហរណ៍នៃម៉ាទ្រីសធុងហ្គេម

តំណាងម៉ាទ្រីសនៃធុងហ្គេមជាមួយនឹងអារេមួយវិមាត្រ

ឧទាហរណ៍ជាក់ស្តែងបន្ថែមទៀតនៃការតំណាងម៉ាទ្រីសដោយអារេមួយវិមាត្រ

ប៉ុន្តែការចូលទៅកាន់ធាតុនៃអារេកើតឡើងនៅក្នុងរង្វិលជុំទ្វេ ហាក់ដូចជាវាមិនមែនជាវិមាត្រមួយ ប៉ុន្តែជាអារេពីរវិមាត្រ។ នេះត្រូវបានធ្វើដោយសារតែយើងនៅតែធ្វើការជាមួយម៉ាទ្រីស។

ឆ្លងកាត់អារេមួយវិមាត្រក្នុងរង្វិលជុំទ្វេ។ Y គឺជាលេខសម្គាល់ជួរដេក X គឺជាលេខសម្គាល់ជួរឈរ

សូមចំណាំថាជំនួសឱ្យការកំណត់អត្តសញ្ញាណម៉ាទ្រីសធម្មតា i, j, ខ្ញុំប្រើ identifiers x និង y ។ អញ្ចឹង​វា​ហាក់​ដូច​ជា​ខ្ញុំ​កាន់​តែ​គាប់​ភ្នែក និង​ច្បាស់​ជាង​មុន​ដល់​ខួរក្បាល។ លើសពីនេះ សញ្ញាណបែបនេះធ្វើឱ្យវាអាចធ្វើទៅបានយ៉ាងងាយស្រួលក្នុងការបញ្ចាំងម៉ាទ្រីសដែលបានប្រើទៅលើអ័ក្សកូអរដោនេនៃរូបភាពពីរវិមាត្រ។

ឥឡូវនេះអំពីភីកសែល ពណ៌ និងការបង្ហាញ។ មុខងារ StretchDIBits (បឋមកថា៖ windows.h; បណ្ណាល័យ៖ gdi32.lib) ត្រូវបានប្រើសម្រាប់លទ្ធផល។ ក្នុងចំណោមរបស់ផ្សេងទៀត ខាងក្រោមនេះត្រូវបានបញ្ជូនទៅមុខងារនេះ៖ ឧបករណ៍ដែលរូបភាពត្រូវបានបង្ហាញ (ក្នុងករណីរបស់ខ្ញុំ នេះគឺជាកុងសូលវីនដូ) កូអរដោនេនៃការចាប់ផ្តើមបង្ហាញរូបភាព ទទឹង/កម្ពស់របស់វា និងរូបភាព។ ខ្លួនវានៅក្នុងទម្រង់នៃផែនទីប៊ីត (ប៊ីតផែនទី) ដែលតំណាងដោយអារេនៃបៃ។ 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 Memory 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 មានពណ៌ប្រផេះងងឹត។ល។ ដូច្នេះយើងអាចនិយាយបានថាយើងមានម៉ាទ្រីសនៃវាលលេង ដែលលេខនីមួយៗគឺជាប្រភេទពណ៌មួយចំនួន។

ដូច្នេះ យើង​មាន​ម៉ាទ្រីស​ជា​លេខ​នៃ​វាល​លេង​ទាំង​មូល​នៅ​លើ​ដៃ​ម្ខាង និង​ផែនទី​ប៊ីត​សម្រាប់​បង្ហាញ​រូបភាព​នៅ​ម្ខាង​ទៀត។ រហូតមកដល់ពេលនេះ ផែនទីប៊ីតគឺ "ទទេ" - វាមិនទាន់មានព័ត៌មានអំពីភីកសែលនៃពណ៌ដែលចង់បាននោះទេ។ នេះមានន័យថាជំហានចុងក្រោយនឹងត្រូវបំពេញផែនទីប៊ីតជាមួយនឹងព័ត៌មានអំពីភីកសែលនីមួយៗដោយផ្អែកលើម៉ាទ្រីសលេខនៃវាលលេង។ ឧទាហរណ៍នៃការផ្លាស់ប្តូរបែបនេះគឺនៅក្នុងរូបភាពខាងក្រោម។

ឧទាហរណ៍នៃការបំពេញផែនទីប៊ីត (ម៉ាទ្រីសភីកសែល) ជាមួយនឹងព័ត៌មានផ្អែកលើម៉ាទ្រីសលេខ (ម៉ាទ្រីសឌីជីថល) នៃវាលលេង (សន្ទស្សន៍ពណ៌មិនត្រូវគ្នានឹងសន្ទស្សន៍នៅក្នុងហ្គេមទេ)

ខ្ញុំ​ក៏​នឹង​បង្ហាញ​កូដ​ពិត​មួយ​ពី​ហ្គេម​ផង​ដែរ។ colorIndex អថេរ​នៅ​ពេល​ការ​ធ្វើ​ឡើងវិញ​នីមួយៗ​នៃ​រង្វិលជុំ​ត្រូវ​បាន​ផ្តល់​តម្លៃ (សន្ទស្សន៍​ពណ៌) ពី​ម៉ាទ្រីស​ជា​លេខ​នៃ​វាល​លេង (mainDigitalMatrix)។ បន្ទាប់មកពណ៌ខ្លួនវាត្រូវបានសរសេរទៅអថេរពណ៌ដោយផ្អែកលើលិបិក្រម។ លើសពីនេះទៀតពណ៌លទ្ធផលត្រូវបានបែងចែកទៅជាសមាមាត្រនៃពណ៌ក្រហមបៃតងនិងពណ៌ខៀវ (RGB) ។ ហើយរួមជាមួយការចូលបន្ទាត់ (pixelPadding) ព័ត៌មាននេះត្រូវបានសរសេរទៅភីកសែលម្តងហើយម្តងទៀត បង្កើតជារូបភាពពណ៌នៅក្នុងផែនទីប៊ីត។

កូដប្រើទ្រនិច និងប្រតិបត្តិការប៊ីត ដែលអាចពិបាកយល់។ ដូច្នេះខ្ញុំណែនាំអ្នកឱ្យអានដាច់ដោយឡែកពីគ្នានៅកន្លែងណាមួយអំពីរបៀបដែលរចនាសម្ព័ន្ធបែបនេះដំណើរការ។

ការបំពេញផែនទីប៊ីតជាមួយនឹងព័ត៌មានដោយផ្អែកលើម៉ាទ្រីសលេខនៃវាលលេង៖

// 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++ រួចហើយ ពោលគឺខ្ញុំបានពណ៌នាអំពីវត្ថុហ្គេមផ្សេងៗជាមួយនឹងថ្នាក់។ ខ្ញុំបានបង្កើតបណ្តុំផ្ទាល់ខ្លួនរបស់ខ្ញុំ - អ្នកអាចឃើញកូដនៅក្នុងបឋមកថា/Box.h។ ដោយវិធីនេះ ការប្រមូលផ្តុំទំនងជាមានការលេចធ្លាយអង្គចងចាំ។ ទ្រនិចដែលបានប្រើ។ ធ្វើការជាមួយការចងចាំ។ ខ្ញុំត្រូវតែនិយាយថាសៀវភៅបានជួយខ្ញុំច្រើន។ ចាប់ផ្តើម C++ តាមរយៈកម្មវិធីហ្គេម. នេះជាការចាប់ផ្តើមដ៏ល្អសម្រាប់អ្នកចាប់ផ្តើមដំបូងក្នុង C++ ។ វាតូច គួរឱ្យចាប់អារម្មណ៍ និងរៀបចំបានល្អ។

វាត្រូវចំណាយពេលប្រហែលប្រាំមួយខែដើម្បីអភិវឌ្ឍហ្គេមនេះ។ ខ្ញុំបានសរសេរជាចម្បងក្នុងអំឡុងពេលអាហារថ្ងៃត្រង់ និងអាហារសម្រន់នៅកន្លែងធ្វើការ។ គាត់​អង្គុយ​ក្នុង​ផ្ទះបាយ​ការិយាល័យ ដើរ​ជាន់​អាហារ និង​សរសេរ​កូដ។ ឬនៅផ្ទះសម្រាប់អាហារពេលល្ងាច។ ដូច្នេះខ្ញុំទទួលបាន "សង្គ្រាមផ្ទះបាយ" បែបនេះ។ ដូចរាល់ដង ខ្ញុំបានប្រើសៀវភៅកត់ត្រាយ៉ាងសកម្ម ហើយគ្រប់គំនិតទាំងអស់បានកើតនៅក្នុងនោះ។

នៅចុងបញ្ចប់នៃផ្នែកជាក់ស្តែង ខ្ញុំនឹងទាញការស្កេនមួយចំនួននៃសៀវភៅកត់ត្រារបស់ខ្ញុំ។ ដើម្បីបង្ហាញពីអ្វីដែលខ្ញុំកំពុងសរសេរ គូរ រាប់ រចនា…

ការរចនារូបភាពធុង។ និងនិយមន័យនៃចំនួនភីកសែលដែលធុងនីមួយៗគួរកាន់កាប់នៅលើអេក្រង់

ការគណនាក្បួនដោះស្រាយនិងរូបមន្តសម្រាប់ការបង្វិលធុងជុំវិញអ័ក្សរបស់វា។

ដ្យាក្រាមនៃការប្រមូលរបស់ខ្ញុំ (ដែលលេចធ្លាយអង្គចងចាំ ទំនងជា)។ បណ្តុំត្រូវបានបង្កើតជាបញ្ជីភ្ជាប់

ហើយទាំងនេះគឺជាការប៉ុនប៉ងឥតប្រយោជន៍ដើម្បីបញ្ជូលបញ្ញាសិប្បនិម្មិតទៅក្នុងហ្គេម

ទ្រឹស្តី

"សូម្បីតែការធ្វើដំណើរមួយពាន់ម៉ាយក៏ចាប់ផ្តើមដោយជំហានដំបូង" (ប្រាជ្ញាចិនបុរាណ)

តោះផ្លាស់ប្តូរពីការអនុវត្តទៅទ្រឹស្តី! តើអ្នករកពេលវេលាសម្រាប់ចំណង់ចំណូលចិត្តរបស់អ្នកដោយរបៀបណា?

1. កំណត់នូវអ្វីដែលអ្នកពិតជាចង់បាន (អាឡោះអាល័យ នេះជាការលំបាកបំផុត)។
2. កំណត់អាទិភាព។
3. លះបង់ទាំងអស់ "ហួសហេតុ" សម្រាប់ជាប្រយោជន៍នៃអាទិភាពខ្ពស់។
4. ឆ្ពោះទៅរកគោលដៅរបស់អ្នកជារៀងរាល់ថ្ងៃ។
5. កុំរំពឹងថានឹងមានពេលទំនេរពីរឬបីម៉ោងសម្រាប់ចំណង់ចំណូលចិត្ត។

ម៉្យាងវិញទៀត អ្នកត្រូវកំណត់នូវអ្វីដែលអ្នកចង់បាន និងកំណត់អាទិភាព។ ម្យ៉ាងវិញទៀត គេអាចបោះបង់ចោលករណី/គម្រោងមួយចំនួន ក្នុងការពេញចិត្តចំពោះអាទិភាពទាំងនេះ។ ម្យ៉ាង​ទៀត អ្នក​នឹង​ត្រូវ​លះបង់​គ្រប់​យ៉ាង "លើស​ចំណុះ"។ ខ្ញុំបានលឺនៅកន្លែងណាមួយថា ក្នុងជីវិតគួរតែមានសកម្មភាពសំខាន់ៗចំនួនបី។ បន្ទាប់មកអ្នកនឹងអាចដោះស្រាយជាមួយពួកគេតាមរបៀបដែលល្អបំផុត។ ហើយគម្រោង/ទិសដៅបន្ថែមនឹងចាប់ផ្តើមផ្ទុកលើសទម្ងន់។ ប៉ុន្តែនេះគឺទាំងអស់ ប្រហែលជាប្រធានបទ និងបុគ្គល។

មានច្បាប់មាសជាក់លាក់មួយ៖ កុំមានថ្ងៃ 0%! ខ្ញុំបានរៀនអំពីវានៅក្នុងអត្ថបទមួយដោយអ្នកអភិវឌ្ឍន៍អ៊ីនឌី។ ប្រសិនបើអ្នកកំពុងធ្វើការលើគម្រោងមួយ បន្ទាប់មកធ្វើអ្វីមួយអំពីវាជារៀងរាល់ថ្ងៃ។ ហើយវាមិនសំខាន់ទេថាតើអ្នករកបានប៉ុន្មាន។ សរសេរ​ពាក្យ​មួយ​ឃ្លា ឬ​មួយ​បន្ទាត់​នៃ​កូដ មើល​វីដេអូ​បង្រៀន​មួយ ឬ​ញញួរ​ក្រចក​មួយ​ទៅ​ក្នុង​ក្ដារខៀន—គ្រាន់តែ​ធ្វើ​អ្វី​មួយ។ ផ្នែកដ៏លំបាកបំផុតគឺការចាប់ផ្តើម។ នៅពេលអ្នកចាប់ផ្តើម អ្នកប្រហែលជានឹងធ្វើច្រើនជាងអ្វីដែលអ្នកចង់ធ្វើ។ ដូច្នេះអ្នកនឹងបន្តឆ្ពោះទៅរកគោលដៅរបស់អ្នក ហើយជឿខ្ញុំយ៉ាងលឿន។ យ៉ាងណាមិញ ហ្វ្រាំងសំខាន់លើអ្វីៗទាំងអស់គឺការពន្យារពេល។

ហើយវាជាការសំខាន់ក្នុងការចងចាំថាអ្នកមិនគួរមើលស្រាលនិងមិនអើពើនឹង " sawdust" ឥតគិតថ្លៃនៃពេលវេលាក្នុងរយៈពេល 5, 10, 15 នាទីរង់ចាំ "កំណត់ហេតុ" ធំ ៗ មានរយៈពេលមួយម៉ោងឬពីរ។ តើអ្នកកំពុងឈរជាជួរទេ? គិតអំពីអ្វីមួយសម្រាប់គម្រោងរបស់អ្នក។ តើអ្នកឡើងជណ្តើរយន្តទេ? សរសេរអ្វីមួយនៅក្នុងសៀវភៅកត់ត្រា។ តើអ្នកញ៉ាំនៅលើឡានក្រុងទេ? មិនអីទេ អានអត្ថបទខ្លះ។ ប្រើគ្រប់ឱកាស។ ឈប់មើលឆ្មា និងឆ្កែនៅលើ YouTube! កុំច្រលំខួរក្បាល!

ហើយចុងក្រោយ។ ប្រសិនបើបន្ទាប់ពីអានអត្ថបទនេះ អ្នកចូលចិត្តគំនិតបង្កើតហ្គេមដោយមិនប្រើម៉ាស៊ីនហ្គេម នោះចាំឈ្មោះ Casey Muratori ។ បុរសនេះមាន វេបសាយ. នៅក្នុងផ្នែក "មើល -> វគ្គមុន" អ្នកនឹងឃើញការបង្រៀនវីដេអូឥតគិតថ្លៃដ៏អស្ចារ្យអំពីរបៀបបង្កើតហ្គេមអាជីពពីដំបូង។ អ្នកអាចស្វែងយល់បន្ថែមនៅក្នុងមេរៀន Intro to C ចំនួនប្រាំសម្រាប់ Windows ជាជាងរយៈពេលប្រាំឆ្នាំនៃការសិក្សានៅសាកលវិទ្យាល័យ (មាននរណាម្នាក់បានសរសេរអំពីរឿងនេះនៅក្នុងមតិយោបល់នៅក្រោមវីដេអូ)។

Casey ក៏ពន្យល់ថា តាមរយៈការអភិវឌ្ឍម៉ាស៊ីនហ្គេមផ្ទាល់ខ្លួនរបស់អ្នក អ្នកនឹងយល់កាន់តែច្បាស់អំពីម៉ាស៊ីនដែលមានស្រាប់ណាមួយ។ នៅក្នុងពិភពនៃក្របខ័ណ្ឌ ដែលមនុស្សគ្រប់គ្នាកំពុងព្យាយាមធ្វើស្វ័យប្រវត្តិកម្ម អ្នកនឹងរៀនពីរបៀបបង្កើត មិនមែនប្រើទេ។ ស្វែងយល់ពីធម្មជាតិនៃកុំព្យូទ័រ។ ហើយ​អ្នក​ក៏​នឹង​ក្លាយ​ជា​អ្នក​សរសេរ​កម្មវិធី​ដែល​មាន​ភាព​ឆ្លាត​វៃ និង​ចាស់​ទុំ​ជាង​នេះ​ដែរ - ជា​អ្នក​គាំទ្រ។

សូមសំណាងល្អនៅលើផ្លូវដែលអ្នកបានជ្រើសរើស! ហើយសូមធ្វើឱ្យពិភពលោកកាន់តែមានជំនាញវិជ្ជាជីវៈ។

អ្នកនិពន្ធ: Grankin Andrey, DevOps

ប្រភព: www.habr.com