DevOps C++ සහ "මුළුතැන්ගෙයි යුද්ධ", හෝ මම ආහාර ගන්නා අතරතුර ක්‍රීඩා ලිවීමට පටන් ගත් ආකාරය

"මම කිසිවක් නොදන්නා බව මම දනිමි" සොක්‍රටීස්

කවුරුන් සඳහාද: සියලුම සංවර්ධකයන්ට කෙළ ගසන සහ ඔවුන්ගේ ක්‍රීඩා කිරීමට කැමති තොරතුරු තාක්ෂණ පුද්ගලයින් සඳහා!

කුමක් ගැන ද: ඔබට අවශ්‍ය නම් C/C++ හි ක්‍රීඩා ලිවීම ආරම්භ කරන්නේ කෙසේද!

ඔබ මෙය කියවිය යුත්තේ ඇයි: යෙදුම් සංවර්ධනය මගේ වැඩ විශේෂත්වය නොවේ, නමුත් මම සෑම සතියකම කේත කිරීමට උත්සාහ කරමි. මම ක්රීඩා වලට කැමති නිසා!

හෙලෝ මගේ නම Andrey Grankin, මම ලක්සොෆ්ට් හි DevOps කෙනෙක්. යෙදුම් සංවර්ධනය මගේ වැඩ විශේෂත්වය නොවේ, නමුත් මම සෑම සතියකම කේත කිරීමට උත්සාහ කරමි. මම ක්රීඩා වලට කැමති නිසා!

පරිගණක ක්‍රීඩා කර්මාන්තය දැවැන්තය, අද චිත්‍රපට කර්මාන්තයටත් වඩා කටකතා පැතිරෙයි. නවීන ප්රමිතීන්, සංකීර්ණ සහ මූලික සංවර්ධන ක්රම භාවිතා කරමින් පරිගණක සංවර්ධනය ආරම්භයේ සිට ක්රීඩා ලියා ඇත. කාලයාගේ ඇවෑමෙන්, ක්‍රීඩා එන්ජින් දැනටමත් ක්‍රමලේඛනය කරන ලද ග්‍රැෆික්ස්, භෞතික විද්‍යාව සහ ශබ්දය සමඟ පෙනී සිටීමට පටන් ගත්තේය. ක්රීඩාවේම සංවර්ධනය කෙරෙහි අවධානය යොමු කිරීමට සහ එහි පදනම ගැන කරදර නොවී සිටීමට ඔවුන් ඔබට ඉඩ සලසයි. නමුත් ඔවුන් සමඟ, එන්ජින් සමඟ, සංවර්ධකයින් "අන්ධ" සහ පිරිහීමට ලක් වේ. ක්රීඩා නිෂ්පාදනයම වාහකය මත තබා ඇත. නිෂ්පාදනයේ ප්‍රමාණය එහි ගුණාත්මක භාවයට වඩා බලවත් වීමට පටන් ගනී.

ඒ අතරම, වෙනත් පුද්ගලයින්ගේ ක්‍රීඩා කරන විට, වෙනත් පුද්ගලයින් විසින් ඉදිරිපත් කරන ලද ස්ථාන, කුමන්ත්‍රණය, චරිත, ක්‍රීඩා යාන්ත්‍ර විද්‍යාව මගින් අප නිරන්තරයෙන් සීමා වේ. ඉතින් මට ඒක තේරුනා...

මට පමණක් යටත්ව ඔබේම ලෝක නිර්මාණය කිරීමට කාලයයි. මම පියාණන්, පුත්‍රයා සහ ශුද්ධාත්මයාණන් සිටින ලෝක!

ඔබේම ක්‍රීඩා එන්ජිමක් සහ එහි ක්‍රීඩාවක් ලිවීමෙන්, ඔබට ඔබේ ඇස් විවෘත කිරීමට, ජනේල පිස දැමීමට සහ ඔබේ කුටිය පොම්ප කිරීමට, වඩාත් පළපුරුදු සහ ඒකාබද්ධ ක්‍රමලේඛකයෙකු වීමට හැකි වනු ඇතැයි මම අවංකවම විශ්වාස කරමි.

මෙම ලිපියෙන් මම ඔබට කියන්නට උත්සාහ කරන්නේ මම C / C ++ හි කුඩා ක්‍රීඩා ලිවීමට පටන් ගත් ආකාරය, සංවර්ධන ක්‍රියාවලිය කුමක්ද සහ කාර්යබහුල පරිසරයක විනෝදාංශයක් සඳහා කාලය සොයා ගන්නේ කොතැනද යන්නයි. එය ආත්මීය වන අතර තනි පුද්ගල ආරම්භයේ ක්රියාවලිය විස්තර කරයි. නොදැනුවත්කම සහ ඇදහිල්ල පිළිබඳ ද්රව්ය, මේ මොහොතේ ලෝකය පිළිබඳ මගේ පෞද්ගලික පින්තූරය ගැන. වෙනත් වචන වලින් කිවහොත්, "ඔබගේ පුද්ගලික මොළයට පරිපාලනය වගකිව යුතු නොවේ!".

පුහුණු වන්න

"පුහුණුවකින් තොරව දැනුම නිෂ්ඵල ය, දැනුමෙන් තොරව පුහුණුව භයානක ය." කොන්ෆියුසියස්

මගේ සටහන් පොත මගේ ජීවිතයයි!

එබැවින්, ප්රායෝගිකව, මා සඳහා සෑම දෙයක්ම සටහන් පොතකින් ආරම්භ වන බව මට පැවසිය හැකිය. මම එහි මගේ දෛනික කාර්යයන් පමණක් නොව, ඇඳීම, වැඩසටහන් කිරීම, ගැලීම් සටහන් සැලසුම් කිරීම සහ ගණිතය ඇතුළු ගැටළු විසඳීම ද ලියා තබමි. සෑම විටම නොට්පෑඩ් භාවිතා කර පැන්සලකින් පමණක් ලියන්න. එය පිරිසිදු, සුවපහසු සහ විශ්වසනීය, IMHO.

මගේ (දැනටමත් පුරවා ඇති) සටහන් පොත. එය පෙනෙන ආකාරය මෙයයි. එහි එදිනෙදා කාර්යයන්, අදහස්, චිත්‍ර, රූප සටහන්, විසඳුම්, කළු පොත් තැබීම, කේතය සහ යනාදිය අඩංගු වේ.

මෙම අදියරේදී, මම ව්යාපෘති තුනක් සම්පූර්ණ කිරීමට සමත් විය (මෙය "අවසානය" පිළිබඳ මගේ අවබෝධය තුළ, ඕනෑම නිෂ්පාදනයක් සාපේක්ෂව නිමක් නැතිව සංවර්ධනය කළ හැකි බැවිනි).

• ව්යාපෘතිය 0: මෙය Unity ගේම් එන්ජිම භාවිතයෙන් C# වලින් ලියා ඇති Architect Demo 3D දර්ශනයකි. macOS සහ Windows වේදිකා සඳහා.
• ක්රීඩාව 1: වින්ඩෝස් සඳහා සරල සර්ප (සියල්ලන් විසින් "සර්පයා" ලෙස හඳුන්වන) කොන්සෝල් ක්‍රීඩාව. C වලින් ලියා ඇත.
• ක්රීඩාව 2: console game Crazy Tanks (හැමෝම දන්නා "Tanks"), දැනටමත් C ++ (පන්ති භාවිතා කරමින්) සහ Windows යටතේ ලියා ඇත.

ව්‍යාපෘතිය 0 ගෘහ නිර්මාණ ශිල්පී ආදර්ශනය

• වේදිකාව: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• භාෂා: C#
• ක්‍රීඩා එන්ජිම: සමගිය
• ආශ්වාදය: ඩැරින් ලිලී
• ගබඩාව: GitHub

3D Scene Architect Demo

පළමු ව්‍යාපෘතිය ක්‍රියාත්මක කරන ලද්දේ C/C++ වල නොව C# වල Unity game එන්ජිම භාවිතා කරමිනි. මෙම එන්ජිම දෘඩාංග මත තරම් ඉල්ලුමක් නොතිබුණි Unreal Engine, සහ ස්ථාපනය කිරීමට සහ භාවිතා කිරීමට මට පහසු විය. මම වෙනත් එන්ජින් සලකා බැලුවේ නැත.

මට යුනිටි එකේ ඉලක්කය වුණේ යම් ආකාරයක ක්‍රීඩාවක් දියුණු කිරීම නොවේ. මට අවශ්‍ය වුණා යම් ආකාරයක චරිතයක් සහිත ත්‍රිමාණ දර්ශනයක් නිර්මාණය කරන්න. ඔහු හෝ ඒ වෙනුවට ඇය (මම ආදරය කළ ගැහැණු ළමයා ආදර්ශයට ගත්තා =) බාහිර ලෝකය සමඟ ගමන් කිරීමට සහ අන්තර් ක්රියා කිරීමට සිදු විය. සමගිය යනු කුමක්ද, සංවර්ධන ක්‍රියාවලිය කුමක්ද සහ යමක් නිර්මාණය කිරීමට කොපමණ උත්සාහයක් ගත යුතුද යන්න තේරුම් ගැනීම පමණක් වැදගත් විය. Architect Demo ව්‍යාපෘතිය බිහි වූයේ එලෙසිනි (නම සොයා ගත්තේ ගොන් කතා වලින්). ක්‍රමලේඛනය, ආකෘති නිර්මාණය, සජීවිකරණය, වයනය කිරීම මට බොහෝ විට දිනපතා වැඩ කිරීමට මාස දෙකක් ගත විය.

මම YouTube හි 3D ආකෘති නිර්මාණය කරන්නේ කෙසේද යන්න පිළිබඳ නිබන්ධන වීඩියෝ සමඟ ආරම්භ කළෙමි බ්ලෙන්ඩර්. බ්ලෙන්ඩර් යනු ස්ථාපනය අවශ්‍ය නොවන ත්‍රිමාණ ආකෘති නිර්මාණය (සහ තවත්) සඳහා විශිෂ්ට නිදහස් මෙවලමකි. මෙහිදී මට කම්පනයක් ඇති විය ... ආකෘති නිර්මාණය, සජීවිකරණය, පෙළගැස්ම ඔබට පොත් ලිවිය හැකි විශාල වෙනම මාතෘකා බව පෙනේ. චරිත සඳහා මෙය විශේෂයෙන්ම සත්ය වේ. ඇඟිලි, දත්, ඇස් සහ ශරීරයේ අනෙකුත් කොටස් ආකෘති කිරීමට, ඔබට ව්‍යුහ විද්‍යාව පිළිබඳ දැනුම අවශ්‍ය වේ. මුහුණේ මාංශ පේශි සකස් කර ඇත්තේ කෙසේද? මිනිසුන් ගමන් කරන්නේ කෙසේද? මට එක් එක් අත, කකුල, ඇඟිල්ල, නකල්ස් වලට අස්ථි "ඇතුළත් කිරීමට" සිදු විය!

සජීවීකරණය ස්වභාවිකව පෙනෙන පරිදි, clavicle, අතිරේක අස්ථි ලීවර ආකෘති කරන්න. එවැනි පාඩම් වලින් පසුව, සජීවිකරණ චිත්‍රපටවල නිර්මාපකයින් තත්පර 30 ක වීඩියෝවක් නිර්මාණය කිරීම සඳහා කරන විශාල කාර්යය කුමක්දැයි ඔබට වැටහෙනු ඇත. නමුත් ත්‍රිමාණ චිත්‍රපට පැය ගණනක් පවතිනවා! ඊට පස්සේ අපි සිනමාහල්වලින් එළියට ඇවිත් මෙහෙම දෙයක් කියනවා: “ටා, ජරා කාටූන් / චිත්‍රපටියක්! ඔවුන්ට මීට වඩා හොඳ දෙයක් කරන්න තිබුණා...” මෝඩයෝ!

මෙම ව්‍යාපෘතියේ ක්‍රමලේඛනය පිළිබඳ තවත් එක් දෙයක්. එය සිදු වූ පරිදි, මට වඩාත්ම සිත්ගන්නා කොටස වූයේ ගණිතමය කොටසයි. ඔබ දර්ශනය ධාවනය කරන්නේ නම් (ව්‍යාපෘති විස්තරයේ ඇති ගබඩාවට සබැඳිය), කැමරාව ගැහැණු චරිතය වටා ගෝලයක භ්‍රමණය වන බව ඔබට පෙනෙනු ඇත. එවැනි කැමරා භ්‍රමණයක් ක්‍රමලේඛනය කිරීම සඳහා, මට මුලින්ම රවුමේ (2D) පිහිටුම් ලක්ෂ්‍යයේ ඛණ්ඩාංක ගණනය කිරීමට සිදු විය, පසුව ගෝලයේ (3D). හාස්‍යය නම් මම පාසලේදී ගණිතයට වෛර කළ අතර එය අඩුවෙන් දැන සිටීමයි. අර්ධ වශයෙන්, බොහෝ විට, පාසැලේදී ඔවුන් සරලවම මෙම ගණිතය ජීවිතයට අදාළ වන්නේ කෙසේදැයි ඔබට පැහැදිලි නොකරන බැවිනි. නමුත් ඔබ ඔබේ ඉලක්කය, සිහිනය ගැන උමතු වූ විට, මනස නිරවුල් වේ, හෙළිදරව් වේ! ඔබ සංකීර්ණ කාර්යයන් උද්යෝගිමත් වික්‍රමාන්විතයක් ලෙස වටහා ගැනීමට පටන් ගනී. එවිට ඔබ සිතන්නේ: "හොඳයි, *ආදරණීය* ගණිතඥයෙකුට සාමාන්‍යයෙන් මෙම සූත්‍ර නැඹුරු විය හැක්කේ කොතැනටදැයි පැවසිය නොහැක්කේ ඇයි?".

රවුමක සහ ගෝලයක ලක්ෂ්‍යයක ඛණ්ඩාංක ගණනය කිරීම සඳහා සූත්‍ර ගණනය කිරීම (මගේ සටහන් පොතෙන්)

ක්රීඩාව 1

• වේදිකාව: වින්ඩෝස් (වින්ඩෝස් 7, 10 මත පරීක්ෂා කර ඇත)
• භාෂා: මම හිතන්නෙ ඒක සුද්ද C වලින් ලියල තියෙනව
• ක්‍රීඩා එන්ජිම: වින්ඩෝස් කොන්සෝලය
• ආශ්වාදය: javidx9
• ගබඩාව: GitHub

සරල සර්ප ක්‍රීඩාව

3D දර්ශනය ක්රීඩාවක් නොවේ. මීට අමතරව, ත්‍රිමාණ වස්තූන් (විශේෂයෙන් චරිත) ආකෘතිකරණය සහ සජීවිකරණය දිගු හා දුෂ්කර ය. යුනිටි සමඟ සෙල්ලම් කිරීමෙන් පසු, මට මූලික කරුණු වලින් ඉදිරියට යා යුතු බව හෝ ඒ වෙනුවට ආරම්භ කළ යුතු බව මට වැටහුණි. ක්‍රීඩා වල ව්‍යුහය තේරුම් ගැනීමට සරල හා වේගවත්, නමුත් ඒ සමඟම ගෝලීය දෙයක්.

සහ අපට සරල හා වේගවත් මොනවාද? ඒක හරි, කොන්සෝලය සහ 2D. වඩාත් නිවැරදිව, කොන්සෝලය සහ සංකේත පවා. නැවතත්, මම අන්තර්ජාලයේ ආශ්වාදයක් සෙවීමට පටන් ගතිමි (සාමාන්‍යයෙන්, මම අන්තර්ජාලය XNUMX වන සියවසේ වඩාත්ම විප්ලවීය හා භයානක සොයා ගැනීම ලෙස සලකමි). මම කොන්සෝල් ටෙට්‍රිස් සෑදූ එක් ක්‍රමලේඛකයෙකුගේ වීඩියෝවක් හාරා බැලුවෙමි. ඔහුගේ ක්‍රීඩාවේ ස්වරූපයෙන් ඔහු "සර්පයා" කපා දැමීමට තීරණය කළේය. වීඩියෝවෙන්, මම මූලික කරුණු දෙකක් ගැන ඉගෙන ගත්තෙමි - ගේම් ලූප් (මූලික ශ්‍රිත / කොටස් තුනක් සහිත) සහ බෆරයට ප්‍රතිදානය.

ක්‍රීඩා ලූපය මේ වගේ දෙයක් විය හැකිය:

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

කේතය මඟින් සම්පූර්ණ ප්‍රධාන () ශ්‍රිතයම එකවර ඉදිරිපත් කරයි. ක්‍රීඩා චක්‍රය ආරම්භ වන්නේ අනුරූප අදහස් දැක්වීමෙන් පසුවය. ලූපයේ මූලික ශ්‍රිත තුනක් ඇත: Input(), Logic(), Draw(). පළමුව, ආදාන දත්ත ආදානය (ප්‍රධාන වශයෙන් යතුරු එබීම් පාලනය), පසුව ඇතුළත් කළ දත්ත ලොජික් සැකසීම, පසුව තිරය මත ප්‍රදර්ශනය කිරීම - ඇඳීම. ඒ වගේම හැම රාමුවක්ම. Animation නිර්මාණය වෙන්නේ මේ විදියට. ඒක හරියට කාටූන් වගේ. සාමාන්‍යයෙන් ආදාන දත්ත සැකසීමට වැඩි කාලයක් ගත වන අතර, මා දන්නා පරිදි, ක්‍රීඩාවේ රාමු අනුපාතය තීරණය කරයි. නමුත් මෙහි Logic() ශ්‍රිතය ඉතා වේගවත් වේ. එබැවින්, මෙම අනුපාතය තීරණය කරන GameSpeed ​​පරාමිතිය සමඟ Sleep() ශ්‍රිතය මඟින් රාමු අනුපාතය පාලනය කළ යුතුය.

ක්රීඩා චක්රය. නොට්පෑඩ් හි සර්ප වැඩසටහන්කරණය

ඔබ සංකේතාත්මක කොන්සෝල ක්‍රීඩාවක් සංවර්ධනය කරන්නේ නම්, සාමාන්‍ය ප්‍රවාහ ප්‍රතිදානය '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 පිස්සු ටැංකි

• වේදිකාව: වින්ඩෝස් (වින්ඩෝස් 7, 10 මත පරීක්ෂා කර ඇත)
• භාෂා: සී ++
• ක්‍රීඩා එන්ජිම: වින්ඩෝස් කොන්සෝලය
• ආශ්වාදය: පොතක් ක්‍රීඩා ක්‍රමලේඛනය හරහා C++ ආරම්භ කිරීම
• ගබඩාව: GitHub

පිස්සු ටැංකි ක්‍රීඩාව

කොන්සෝලයට අක්ෂර මුද්‍රණය කිරීම ඔබට ක්‍රීඩාවක් බවට පත් කළ හැකි සරලම දෙය විය හැකිය. නමුත් පසුව එක් කරදරයක් දිස්වේ: අක්ෂරවල විවිධ උස සහ පළල ඇත (උස පළලට වඩා වැඩි වේ). මේ අනුව, සෑම දෙයක්ම අසමානුපාතික ලෙස පෙනෙන අතර, පහළට හෝ ඉහළට ගමන් කිරීම වමට හෝ දකුණට ගමන් කිරීමට වඩා වේගවත් බව පෙනේ. මෙම බලපෑම "සර්පයා" (ක්‍රීඩාව 1) හි ඉතා කැපී පෙනේ. "ටැංකි" (ක්‍රීඩාව 2) එවැනි අඩුපාඩුවක් නොමැත, මන්ද එහි ප්‍රතිදානය විවිධ වර්ණ සහිත තිර පික්සෙල් පින්තාරු කිරීමෙන් සංවිධානය කර ඇත. මම රෙන්ඩරර් එකක් ලිව්වා යැයි ඔබට පැවසිය හැකිය. ඇත්ත, මෙය දැනටමත් ටිකක් සංකීර්ණයි, නමුත් වඩා රසවත්.

මෙම ක්‍රීඩාව සඳහා, තිරය මත පික්සල පෙන්වීම සඳහා මගේ පද්ධතිය විස්තර කිරීමට එය ප්‍රමාණවත් වේ. මම හිතන්නේ මෙය ක්‍රීඩාවේ ප්‍රධාන කොටසයි. තවද ඔබට ඔබම ඉදිරිපත් කළ හැකි අනෙක් සියල්ල.

ඉතින්, ඔබ තිරය මත දකින්නේ චලනය වන වර්ණ සෘජුකෝණාස්රාකාර කට්ටලයක් පමණි.

සෘජුකෝණාස්රාකාර කට්ටලය

සෑම සෘජුකෝණාස්රයක්ම සංඛ්යා පිරවූ න්යාසයකින් නියෝජනය වේ. මාර්ගය වන විට, මට එක් රසවත් සූක්ෂ්මතාවයක් ඉස්මතු කළ හැකිය - ක්‍රීඩාවේ සියලුම න්‍යාසයන් ඒක මාන අරාවක් ලෙස වැඩසටහන්ගත කර ඇත. ද්විමාන නොවේ, නමුත් ඒක මාන! එක්-මාන අරාවන් සමඟ වැඩ කිරීමට වඩා පහසු සහ වේගවත් වේ.

ක්රීඩා ටැංකි අනුකෘතියක උදාහරණයක්

ඒකමාන අරාවක් සහිත ක්‍රීඩා ටැංකියක අනුකෘතිය නියෝජනය කිරීම

ඒක මාන අරාවක් මගින් අනුකෘති නිරූපණයක වඩාත් නිදර්ශන උදාහරණයක්

නමුත් අරාවේ මූලද්‍රව්‍ය වෙත ප්‍රවේශ වීම ද්විත්ව පුඩුවක් තුළ සිදු වේ, එය ඒක මානයක් නොව ද්විමාන අරාවක් ලෙස ය. අපි තවමත් matrices සමඟ වැඩ කරන නිසා මෙය සිදු කෙරේ.

ද්විත්ව ලූපයක් තුළ ඒකමාන අරාවක් ගමන් කිරීම. Y යනු පේළි ID, X යනු තීරු හැඳුනුම වේ

සාමාන්‍ය න්‍යාස හඳුනාගැනීම් i, j වෙනුවට මම x සහ y හඳුනාගැනීම් භාවිතා කරන බව කරුණාවෙන් සලකන්න. ඉතින්, එය මට පෙනෙන පරිදි, ඇසට වඩාත් ප්රසන්න හා මොළයට වඩා පැහැදිලිය. මීට අමතරව, එවැනි අංකනයක් මඟින් ද්විමාන රූපයක ඛණ්ඩාංක අක්ෂ මත භාවිතා කරන න්‍යාස පහසුවෙන් ප්‍රක්ෂේපණය කිරීමට හැකි වේ.

දැන් පික්සල්, වර්ණය සහ සංදර්ශකය ගැන. ප්‍රතිදානය සඳහා StretchDIBits ශ්‍රිතය (ශීර්ෂකය: windows.h; පුස්තකාලය: gdi32.lib) භාවිතා වේ. වෙනත් දේ අතර, පහත සඳහන් දේ මෙම කාර්යයට යවනු ලැබේ: රූපය දර්ශනය වන උපාංගය (මගේ නඩුවේදී, මෙය වින්ඩෝස් කොන්සෝලය වේ), රූපය දර්ශනය කිරීමේ ආරම්භයේ ඛණ්ඩාංක, එහි පළල / උස සහ රූපය එයම bitmap (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() ශ්‍රිතය භාවිතයෙන් මෙම bitmap සඳහා මතකය කල්තියා වෙන් කරනු ලැබේ. එනම්, සියලුම පික්සල පිළිබඳ තොරතුරු ගබඩා කිරීම සඳහා අවශ්ය බයිට් සංඛ්යාව වෙන් කර ඇති අතර, එය තිරය මත දිස්වනු ඇත.

m_p_bitmapMemory 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 තද අළු, ආදිය. මේ අනුව, අපට ක්‍රීඩා පිටියේ අනුකෘතියක් ඇති බව අපට පැවසිය හැකිය, එහිදී එක් එක් අංකය යම් ආකාරයක වර්ණයකි.

එබැවින්, අපට එක් අතකින් සම්පූර්ණ ක්‍රීඩා පිටියේ සංඛ්‍යාත්මක අනුකෘතියක් සහ අනෙක් පැත්තෙන් රූපය පෙන්වීම සඳහා බිට්මැප් එකක් ඇත. මෙතෙක්, බිට්මැප් එක "හිස්" - එය තවමත් අපේක්ෂිත වර්ණ පික්සල පිළිබඳ තොරතුරු නොමැත. මෙයින් අදහස් කරන්නේ ක්‍රීඩා පිටියේ සංඛ්‍යාත්මක න්‍යාසය මත පදනම්ව එක් එක් පික්සලය පිළිබඳ තොරතුරු සමඟ අවසාන පියවර බිට්මැප් පිරවීමයි. එවැනි පරිවර්තනයක් පිළිබඳ නිදර්ශන උදාහරණයක් පහත පින්තූරයේ ඇත.

ක්‍රීඩා පිටියේ සංඛ්‍යාත්මක න්‍යාසය (ඩිජිටල් න්‍යාසය) මත පදනම් වූ තොරතුරු සමඟ බිට්මැප් (පික්සල් න්‍යාසය) පිරවීමේ උදාහරණයක් (වර්ණ දර්ශක ක්‍රීඩාවේ දර්ශක සමඟ නොගැලපේ)

මමත් ගේම් එකෙන් නියම කෝඩ් කෑල්ලක් ඉදිරිපත් කරන්නම්. ලූපයේ සෑම පුනරාවර්තනයකදීම විචල්‍ය වර්ණ දර්ශකයට ක්‍රීඩා පිටියේ සංඛ්‍යාත්මක අනුකෘතියෙන් (mainDigitalMatrix) අගයක් (වර්ණ දර්ශකය) පවරා ඇත. එවිට වර්ණයම දර්ශකය මත පදනම්ව වර්ණ විචල්යයට ලියා ඇත. තවද, ලැබෙන වර්ණය රතු, කොළ සහ නිල් (RGB) අනුපාතයට බෙදී ඇත. සහ indent (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() ශ්‍රිතයේ ඒවා පසුව සැකසීමෙන් පසු, නව පින්තූරයක් (රාමු) සාදනු ලැබේ. ඇත්ත, ක්‍රීඩා වස්තු දැනටමත් ක්‍රීඩා පිටියේ වෙනස් ස්ථානයක් තිබිය හැකි අතර, ඒ අනුව, වෙනත් ස්ථානයක අඳිනු ලැබේ. සජීවිකරණය (චලනය) සිදු වන්නේ එලෙස ය.

න්‍යායාත්මකව (ඔබට කිසිවක් අමතක වී නොමැති නම්), පළමු ක්‍රීඩාවෙන් (“සර්පයා”) ක්‍රීඩා ලූපය සහ දෙවන ක්‍රීඩාවෙන් (“ටැංකි”) තිරය මත පික්සල සංදර්ශන කිරීමේ පද්ධතිය තේරුම් ගැනීම (“ටැංකි”) ඔබට ඕනෑම දෙයක් ලිවීමට අවශ්‍ය වේ. Windows සඳහා ඔබගේ 2D ක්‍රීඩා වලින්. ශබ්ද රහිත! 😉 ඉතිරි කොටස් නිකම්ම නිකම්ම නිකම්ම නිකම්ම නිකම්ම නිකම්.

ඇත්ත වශයෙන්ම, "ටැංකි" ක්රීඩාව "සර්පයා" ට වඩා බෙහෙවින් සංකීර්ණ ලෙස නිර්මාණය කර ඇත. මම දැනටමත් C ++ භාෂාව භාවිතා කර ඇත, එනම්, මම පන්ති සමඟ විවිධ ක්රීඩා වස්තූන් විස්තර කළෙමි. මම මගේම එකතුවක් නිර්මාණය කළෙමි - ඔබට ශීර්ෂක/Box.h හි කේතය දැකිය හැක. මාර්ගය වන විට, එකතුව බොහෝ විට මතක කාන්දුවක් ඇත. භාවිත දර්ශක. මතකයෙන් වැඩ කළා. පොත මට ගොඩක් උදව් කළ බව මම පැවසිය යුතුයි. ක්‍රීඩා ක්‍රමලේඛනය හරහා C++ ආරම්භ කිරීම. C++ හි ආරම්භකයින් සඳහා මෙය හොඳ ආරම්භයකි. එය කුඩා, රසවත් හා හොඳින් සංවිධානය වී ඇත.

මෙම ක්‍රීඩාව දියුණු කිරීමට මාස හයක් පමණ ගත විය. මම ප්‍රධාන වශයෙන් ලිව්වේ දිවා ආහාරය සහ වැඩ කරන විට කෙටි කෑම අතරතුරයි. ඔහු ඔෆිස් කුස්සියේ ඉඳගෙන කෑම පාගලා කෝඩ් ලිව්වා. නැත්නම් රෑ කෑමට ගෙදර. ඉතින් මට එවැනි "කුස්සි යුද්ධ" ලැබුණා. සෑම විටම, මම ක්රියාශීලීව සටහන් පොතක් භාවිතා කළ අතර, සියලු සංකල්පීය දේවල් එය තුළ උපත ලැබීය.

ප්‍රායෝගික කොටස අවසානයේදී, මම මගේ සටහන් පොතේ ස්කෑන් කිහිපයක් එළියට ගන්නෙමි. මා ලිවීම, ඇඳීම, ගණන් කිරීම, සැලසුම් කිරීම හරියටම කුමක්දැයි පෙන්වීමට...

ටැංකි රූප නිර්මාණය. සහ එක් එක් ටැංකිය තිරය මත කොපමණ පික්සල් ගණනක් තිබිය යුතුද යන්න පිළිබඳ නිර්වචනය

එහි අක්ෂය වටා ටැංකියේ භ්රමණය සඳහා ඇල්ගොරිතම සහ සූත්ර ගණනය කිරීම

මගේ එකතුවේ රූප සටහන (මතක කාන්දුවක් ඇති, බොහෝ දුරට ඉඩ ඇත). එකතුව සබැඳි ලැයිස්තුවක් ලෙස නිර්මාණය කර ඇත

තවද මේවා කෘත්‍රිම බුද්ධිය ක්‍රීඩාවට ඇතුළත් කිරීමේ නිෂ්ඵල උත්සාහයන් වේ

න්‍යාය

"සැතපුම් දහසක ගමනක් පවා පළමු පියවරෙන් ආරම්භ වේ" (පුරාණ චීන ප්රඥාව)

අපි ප්‍රායෝගිකව න්‍යායට යමු! ඔබේ විනෝදාංශය සඳහා කාලය සොයා ගන්නේ කෙසේද?

1. ඔබට සැබවින්ම අවශ්‍ය දේ තීරණය කරන්න (අහෝ, මෙය වඩාත්ම දුෂ්කර ය).
2. ප්‍රමුඛතා සකසන්න.
3. ඉහළ ප්‍රමුඛතා සඳහා සියලු "අතිරික්ත" පරිත්‍යාග කරන්න.
4. සෑම දිනකම ඔබේ ඉලක්ක කරා ගමන් කරන්න.
5. විනෝදාංශයක් සඳහා පැය දෙකක් හෝ තුනක් නිදහස් කාලයක් ලැබෙනු ඇතැයි අපේක්ෂා නොකරන්න.

එක් අතකින්, ඔබට අවශ්ය දේ තීරණය කිරීමට සහ ප්රමුඛත්වය දිය යුතුය. අනෙක් අතට, මෙම ප්‍රමුඛතාවයන්ට පක්ෂව සමහර අවස්ථා / ව්‍යාපෘති අතහැර දැමිය හැකිය. වෙනත් වචන වලින් කිවහොත්, ඔබට "අතිරික්ත" සියල්ල කැප කිරීමට සිදුවනු ඇත. ජීවිතයේ උපරිම වශයෙන් ප්‍රධාන ක්‍රියාකාරකම් තුනක් තිබිය යුතු බව මම කොතැනක හෝ අසා ඇත්තෙමි. එවිට ඔබට ඔවුන් සමඟ හොඳම ආකාරයෙන් කටයුතු කිරීමට හැකි වනු ඇත. තවද අමතර ව්‍යාපෘති/දිශාවන් බඩ ඉරිඟු පැටවීමට පටන් ගනී. නමුත් මේ සියල්ල, බොහෝ විට, ආත්මීය සහ තනි පුද්ගලයෙකි.

නිශ්චිත ස්වර්ණමය රීතියක් තිබේ: කිසි විටෙකත් 0% දිනක් නොගන්න! මම ඒ ගැන ඉගෙන ගත්තේ ඉන්ඩි සංවර්ධකයෙකුගේ ලිපියකින්. ඔබ ව්‍යාපෘතියක වැඩ කරන්නේ නම්, සෑම දිනකම ඒ ගැන යමක් කරන්න. අනික කොච්චර හැදුවත් වැඩක් නෑ. එක් වචනයක් හෝ එක් කේතයක් ලියන්න, එක් නිබන්ධන වීඩියෝවක් නරඹන්න, නැතහොත් පුවරුවට එක ඇණයක් ගසන්න-යමක් කරන්න. අමාරුම කොටස ආරම්භ කිරීමයි. ඔබ ආරම්භ කළ පසු, ඔබ බොහෝ විට ඔබට අවශ්‍ය ප්‍රමාණයට වඩා ටිකක් වැඩියෙන් කරනු ඇත. එබැවින් ඔබ නිරන්තරයෙන් ඔබේ ඉලක්කය කරා ගමන් කරනු ඇති අතර, මාව විශ්වාස කරන්න, ඉතා ඉක්මනින්. සියල්ලට පසු, සියලු දේවල ප්රධාන තිරිංග වන්නේ කල් දැමීමයි.

මිනිත්තු 5, 10, 15 කින් නොමිලේ ලැබෙන "sawdust" අවතක්සේරු නොකළ යුතු බව මතක තබා ගැනීම වැදගත්ය, පැයක් හෝ දෙකක් පවතින විශාල "ලොග්" කිහිපයක් බලා සිටින්න. ඔබ පෝලිමේ සිටගෙන සිටිනවාද? ඔබේ ව්යාපෘතිය සඳහා යමක් ගැන සිතන්න. ඔබ එස්කැලේටරයේ ඉහළට යනවාද? සටහන් පොතක යමක් ලියන්න. ඔයා කන්නෙ බස් එකේද? හරි, ලිපියක් කියවන්න. සෑම අවස්ථාවක්ම භාවිතා කරන්න. YouTube හි බළලුන් සහ බල්ලන් නැරඹීම නවත්වන්න! ඔබේ මොළය අවුල් නොකරන්න!

සහ අන්තිම. මෙම ලිපිය කියවීමෙන් පසු, ක්‍රීඩා එන්ජින් භාවිතා නොකර ක්‍රීඩා නිර්මාණය කිරීමේ අදහසට ඔබ කැමති නම්, කේසි මුරටෝරි යන නම මතක තබා ගන්න. මේ මිනිහට තියෙනවා වෙබ් අඩවිය. "watch -> PREVIOUS EPISODES" කොටසේ ඔබට මුල සිටම වෘත්තීය ක්‍රීඩාවක් නිර්මාණය කරන්නේ කෙසේද යන්න පිළිබඳ විස්මිත නොමිලේ වීඩියෝ නිබන්ධන සොයාගත හැකිය. විශ්ව විද්‍යාලයේ වසර පහක අධ්‍යයනයට වඩා ඔබට වින්ඩෝස් පාඩම් සඳහා හැඳින්වීම සිට සී දක්වා වැඩි විස්තර පහකින් ඉගෙන ගත හැකිය (කවුරුහරි මේ ගැන වීඩියෝව යටතේ අදහස් ලියා ඇත).

ඔබේම ක්‍රීඩා එන්ජිමක් සංවර්ධනය කිරීමෙන්, පවතින ඕනෑම එන්ජිමක් පිළිබඳව ඔබට හොඳ අවබෝධයක් ලැබෙනු ඇති බව කේසි පැහැදිලි කරයි. සෑම කෙනෙකුම ස්වයංක්‍රීය කිරීමට උත්සාහ කරන රාමු ලෝකයේ, ඔබ නිර්මාණය කරන්නේ කෙසේදැයි ඉගෙන ගනු ඇත, භාවිතා නොකරයි. පරිගණකවල ස්වභාවය තේරුම් ගන්න. තවද ඔබ වඩාත් බුද්ධිමත් හා පරිණත ක්‍රමලේඛකයෙකු බවට පත්වනු ඇත - ගැති.

ඔබ තෝරාගත් මාර්ගයට සුබ පැතුම්! ඒ වගේම අපි ලෝකය වඩාත් වෘත්තීය බවට පත් කරමු.

කර්තෘ: Grankin Andrey, DevOps

මූලාශ්රය: www.habr.com