DevOps C++ અને "કિચન વોર્સ", અથવા જમતી વખતે મેં કેવી રીતે ગેમ લખવાનું શરૂ કર્યું

"હું જાણું છું કે હું કશું જાણતો નથી." સોક્રેટીસ

જેમના માટે: IT લોકો માટે કે જેઓ બધા વિકાસકર્તાઓની કાળજી લેતા નથી અને તેમની રમતો રમવા માંગે છે!

શેના વિષે: C/C++ માં રમતો લખવાનું કેવી રીતે શરૂ કરવું તે વિશે, જો તમને અચાનક તેની જરૂર હોય તો!

તમારે આ શા માટે વાંચવું જોઈએ: એપ્લિકેશન ડેવલપમેન્ટ એ મારી કુશળતાનું ક્ષેત્ર નથી, પરંતુ હું દર અઠવાડિયે કોડ કરવાનો પ્રયાસ કરું છું. કારણ કે મને રમતો ગમે છે!

નમસ્કાર, મારું નામ છે આન્દ્રે ગ્રેન્કીન, હું Luxoft ખાતે DevOps છું. એપ્લિકેશન ડેવલપમેન્ટ મારી વિશેષતા નથી, પરંતુ હું દર અઠવાડિયે કોડ કરવાનો પ્રયાસ કરું છું. કારણ કે મને રમતો ગમે છે!

કમ્પ્યુટર ગેમિંગ ઉદ્યોગ વિશાળ છે, અફવા છે કે તે આજે મૂવી ઉદ્યોગ કરતાં પણ વિશાળ છે. આધુનિક ધોરણો, જટિલ અને મૂળભૂત વિકાસ પદ્ધતિઓનો ઉપયોગ કરીને, કમ્પ્યુટરની શરૂઆતથી રમતો લખવામાં આવી છે. સમય જતાં, પહેલેથી જ પ્રોગ્રામ કરેલ ગ્રાફિક્સ, ભૌતિકશાસ્ત્ર અને ધ્વનિ સાથેના ગેમ એન્જિન દેખાવા લાગ્યા. તેઓ તમને રમતના વિકાસ પર ધ્યાન કેન્દ્રિત કરવાની અને તેના પાયા વિશે ચિંતા ન કરવા દે છે. પરંતુ તેમની સાથે, એન્જિન સાથે, વિકાસકર્તાઓ "અંધ થઈ જાય છે" અને અધોગતિ કરે છે. રમતોનું ઉત્પાદન પોતે કન્વેયર બેલ્ટ પર મૂકવામાં આવે છે. અને ઉત્પાદનોની માત્રા તેની ગુણવત્તા પર હાવી થવા લાગે છે.

તે જ સમયે, જ્યારે અન્ય લોકોની રમતો રમીએ છીએ, ત્યારે અમે સતત સ્થાનો, પ્લોટ, પાત્રો અને ગેમ મિકેનિક્સ દ્વારા મર્યાદિત હોઈએ છીએ જે અન્ય લોકો સાથે આવ્યા હતા. તેથી મને સમજાયું કે ...

... મારી પોતાની દુનિયા બનાવવાનો સમય આવી ગયો છે, ફક્ત મારા માટે વિષય. વિશ્વો જ્યાં હું પિતા, પુત્ર અને પવિત્ર આત્મા છું!

અને હું નિષ્ઠાપૂર્વક માનું છું કે તમારું પોતાનું ગેમ એન્જિન લખીને અને તેના પર રમીને, તમે તમારા પગરખાં ઉતારી શકશો, બારીઓ સાફ કરી શકશો અને તમારી કેબિનને અપગ્રેડ કરી શકશો, વધુ અનુભવી અને સંપૂર્ણ પ્રોગ્રામર બની શકશો.

આ લેખમાં હું તમને જણાવવાનો પ્રયત્ન કરીશ કે મેં C/C++ માં નાની રમતો કેવી રીતે લખવાનું શરૂ કર્યું, વિકાસ પ્રક્રિયા કેવી છે અને વ્યસ્ત વાતાવરણમાં મને શોખ માટે ક્યાં સમય મળે છે. તે વ્યક્તિલક્ષી છે અને વ્યક્તિગત શરૂઆતની પ્રક્રિયાનું વર્ણન કરે છે. અજ્ઞાન અને વિશ્વાસ વિશેની સામગ્રી, આ ક્ષણે વિશ્વના મારા વ્યક્તિગત ચિત્ર વિશે. બીજા શબ્દોમાં કહીએ તો, "વહીવટ તમારા અંગત મગજ માટે જવાબદાર નથી!"

પ્રેક્ટિસ

"અભ્યાસ વિનાનું જ્ઞાન નકામું છે, જ્ઞાન વિના અભ્યાસ જોખમી છે." કન્ફ્યુશિયસ

મારી નોટબુક એ મારું જીવન છે!

તેથી, વ્યવહારમાં, હું કહી શકું છું કે મારા માટે બધું નોટપેડથી શરૂ થાય છે. હું ત્યાં મારા રોજિંદા કાર્યો લખું છું એટલું જ નહીં, હું ડ્રો, પ્રોગ્રામ, ફ્લોચાર્ટ ડિઝાઇન કરું છું અને ગાણિતિક સહિતની સમસ્યાઓનું નિરાકરણ કરું છું. હંમેશા નોટપેડનો ઉપયોગ કરો અને પેન્સિલમાં જ લખો. તે સ્વચ્છ, અનુકૂળ અને વિશ્વસનીય છે, IMHO.

મારી (પહેલેથી જ ભરેલી) નોટબુક. આ તે જેવો દેખાય છે. તેમાં રોજિંદા કાર્યો, વિચારો, રેખાંકનો, આકૃતિઓ, ઉકેલો, બ્લેક બુકકીપિંગ, કોડ વગેરેનો સમાવેશ થાય છે.

આ તબક્કે, હું ત્રણ પ્રોજેક્ટ્સ પૂર્ણ કરવામાં વ્યવસ્થાપિત થયો (આ "સંપૂર્ણતા" વિશેની મારી સમજમાં છે, કારણ કે કોઈપણ ઉત્પાદન પ્રમાણમાં અનંત રીતે વિકસાવી શકાય છે).

• પ્રોજેક્ટ 0: આ યુનિટી ગેમ એન્જિનનો ઉપયોગ કરીને C# માં લખાયેલું 3D આર્કિટેક્ટ ડેમો દ્રશ્ય છે. macOS અને Windows પ્લેટફોર્મ માટે.
• રમત 1: Windows માટે કન્સોલ ગેમ સિમ્પલ સ્નેક (દરેકને "સાપ" તરીકે ઓળખાય છે). સી માં લખાયેલ.
• રમત 2: કન્સોલ ગેમ Crazy Tanks (દરેકને “Tanks” તરીકે ઓળખાય છે), C++ (વર્ગોનો ઉપયોગ કરીને) અને Windows માટે પણ લખાયેલ છે.

પ્રોજેક્ટ 0. આર્કિટેક્ટ ડેમો

• પ્લેટફોર્મ: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• મહેરબાની: C#
• રમત એન્જિન: એકતા
• પ્રેરણા: ડેરીન લીલ
• ભંડાર: GitHub

3D સીન આર્કિટેક્ટ ડેમો

પ્રથમ પ્રોજેક્ટ C/C++ માં નહીં, પરંતુ યુનિટી ગેમ એન્જિનનો ઉપયોગ કરીને C# માં અમલમાં મૂકવામાં આવ્યો હતો. આ એન્જિન હાર્ડવેર પર એટલું ડિમાન્ડિંગ નહોતું અવાસ્તવિક એન્જિન, અને ઇન્સ્ટોલ અને ઉપયોગમાં સરળ પણ લાગતું હતું. મેં અન્ય એન્જિનોને ધ્યાનમાં લીધા નથી.

યુનિટીમાં મારો ધ્યેય રમતનો વિકાસ કરવાનો નહોતો. હું કોઈ પાત્ર સાથે 3D દ્રશ્ય બનાવવા માંગતો હતો. તેણે, અથવા તેના બદલે તેણી (હું જે છોકરીના પ્રેમમાં હતો તેનું મોડેલ બનાવ્યું =) ને તેની આસપાસની દુનિયા સાથે ફરવું અને સંપર્ક કરવો પડ્યો. એકતા શું છે, વિકાસની પ્રક્રિયા શું છે અને કંઈક બનાવવા માટે કેટલા પ્રયત્નોની જરૂર છે તે સમજવું જ જરૂરી હતું. આ રીતે આર્કિટેક્ટ ડેમો પ્રોજેક્ટનો જન્મ થયો હતો (નામ લગભગ ક્યાંય શોધાયું ન હતું). પ્રોગ્રામિંગ, મોડેલિંગ, એનિમેશન, ટેક્ષ્ચરિંગ મને રોજિંદા કામમાં કદાચ બે મહિના લાગ્યા.

મેં માં 3D મોડલ બનાવવા પર YouTube પર ટ્યુટોરીયલ વિડિઓઝ સાથે શરૂઆત કરી બ્લેન્ડર. બ્લેન્ડર એ 3D મોડેલિંગ (અને વધુ) માટે એક ઉત્તમ મફત સાધન છે જેને ઇન્સ્ટોલેશનની જરૂર નથી. અને અહીં એક આંચકો મારી રાહ જોઈ રહ્યો હતો... તે તારણ આપે છે કે મોડેલિંગ, એનિમેશન, ટેક્સચર એ વિશાળ અલગ વિષયો છે જેના પર તમે પુસ્તકો લખી શકો છો. આ પાત્રો માટે ખાસ કરીને સાચું છે. આંગળીઓ, દાંત, આંખો અને શરીરના અન્ય ભાગોનું મોડેલ બનાવવા માટે, તમારે શરીરરચનાના જ્ઞાનની જરૂર પડશે. ચહેરાના સ્નાયુઓ કેવી રીતે રચાય છે? લોકો કેવી રીતે ખસેડે છે? મારે દરેક હાથ, પગ, આંગળી, આંગળીઓના ફાલેન્જીસમાં હાડકાં "દાખલ કરવા" હતા!

એનિમેશન કુદરતી દેખાવા માટે કોલરબોન્સ અને વધારાના લીવર હાડકાંનું મોડેલ બનાવો. આવા પાઠ પછી, તમને ખ્યાલ આવે છે કે એનિમેટેડ ફિલ્મોના સર્જકો માત્ર 30 સેકન્ડનો વિડિયો બનાવવા માટે કેટલું કામ કરે છે. પરંતુ 3D ફિલ્મો કલાકો સુધી ચાલે છે! અને પછી અમે સિનેમાઘરો છોડીને કંઈક એવું કહીએ છીએ: “તે વાહિયાત કાર્ટૂન/મૂવી છે! તેઓ વધુ સારું કરી શક્યા હોત..." મૂર્ખ!

અને આ પ્રોજેક્ટમાં પ્રોગ્રામિંગ સંબંધિત એક વધુ વસ્તુ. તે બહાર આવ્યું તેમ, મારા માટે સૌથી રસપ્રદ ભાગ ગણિતનો હતો. જો તમે દ્રશ્ય ચલાવો છો (પ્રોજેક્ટ વર્ણનમાં રીપોઝીટરીની લિંક), તો તમે જોશો કે કૅમેરો એક ગોળામાં છોકરીના પાત્રની આસપાસ ફરે છે. કૅમેરાના આવા પરિભ્રમણને પ્રોગ્રામ કરવા માટે, મારે પહેલા વર્તુળ (2D) પર સ્થિત બિંદુના કોઓર્ડિનેટ્સની ગણતરી કરવી પડી હતી, અને પછી ગોળા (3D) પર. મજાની વાત એ છે કે હું શાળામાં ગણિતને નફરત કરતો હતો અને તેને સી-માઈનસથી જાણતો હતો. આંશિક રીતે, કદાચ, કારણ કે શાળામાં તેઓ તમને સમજાવતા નથી કે આ ગણિત જીવનમાં કેવી રીતે લાગુ થાય છે. પરંતુ જ્યારે તમે તમારા ધ્યેય સાથે ભ્રમિત થાઓ છો, ત્યારે તમારું સ્વપ્ન, તમારું મન સાફ થાય છે અને ખુલે છે! અને તમે મુશ્કેલ કાર્યોને એક આકર્ષક સાહસ તરીકે સમજવાનું શરૂ કરો છો. અને પછી તમે વિચારો: "સારું, શા માટે તમારા *મનપસંદ* ગણિતશાસ્ત્રી તમને સામાન્ય રીતે કહી શકતા નથી કે આ સૂત્રો ક્યાં લાગુ કરી શકાય છે?"

વર્તુળ અને ગોળા પરના બિંદુના કોઓર્ડિનેટની ગણતરી કરવા માટેના સૂત્રોની ગણતરી (મારી નોટબુકમાંથી)

રમત 1. સરળ સાપ

• પ્લેટફોર્મ: વિન્ડોઝ (વિન્ડોઝ 7, 10 પર ચકાસાયેલ)
• મહેરબાની: મને લાગે છે કે મેં તેને શુદ્ધ C માં લખ્યું છે
• રમત એન્જિન: વિન્ડોઝ કન્સોલ
• પ્રેરણા: javidx9
• ભંડાર: GitHub

સાપની સાદી રમત

3D દ્રશ્ય એ રમત નથી. વધુમાં, 3D ઑબ્જેક્ટ્સ (ખાસ કરીને અક્ષરો)નું મોડેલિંગ અને એનિમેટ કરવું સમય માંગી લે તેવું અને મુશ્કેલ છે. યુનિટી સાથે રમ્યા પછી, મને અનુભૂતિ થઈ કે મારે મૂળભૂત બાબતોથી ચાલુ રાખવાની અથવા તેના બદલે શરૂ કરવાની જરૂર છે. રમતોની રચનાને સમજવા માટે કંઈક સરળ અને ઝડપી, પરંતુ તે જ સમયે વૈશ્વિક.

સરળ અને ઝડપી શું છે? તે સાચું છે, કન્સોલ અને 2D. વધુ સ્પષ્ટ રીતે, કન્સોલ અને પ્રતીકો પણ. ફરીથી હું ઇન્ટરનેટ પર પ્રેરણા શોધવા ગયો (સામાન્ય રીતે, મને લાગે છે કે ઇન્ટરનેટ એ XNUMXમી સદીની સૌથી ક્રાંતિકારી અને ખતરનાક શોધ છે). મેં એક પ્રોગ્રામરનો વિડિઓ ખોદ્યો જેણે કન્સોલ ટેટ્રિસ બનાવ્યું. અને તેની રમતની સમાનતામાં મેં "સાપ" બનાવવાનું નક્કી કર્યું. વિડિઓમાંથી મેં બે મૂળભૂત બાબતો વિશે શીખ્યા - ગેમ લૂપ (ત્રણ મૂળભૂત કાર્યો/ભાગો સાથે) અને બફરમાં આઉટપુટ.

ગેમ લૂપ આના જેવો દેખાઈ શકે છે:

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

કોડ એક જ સમયે સમગ્ર મુખ્ય() ફંક્શન રજૂ કરે છે. અને યોગ્ય ટિપ્પણી પછી રમત ચક્ર શરૂ થાય છે. લૂપમાં ત્રણ મૂળભૂત કાર્યો છે: Input(), Logic(), Draw(). પ્રથમ, ઇનપુટ ડેટા ઇનપુટ (મુખ્યત્વે કીસ્ટ્રોકનું નિયંત્રણ), પછી દાખલ કરેલ ડેટા લોજિક પર પ્રક્રિયા કરો, પછી સ્ક્રીન પર આઉટપુટ કરો - દોરો. અને તેથી દરેક ફ્રેમ પર. આ રીતે એનિમેશન બનાવવામાં આવે છે. તે કાર્ટૂન જેવું છે. સામાન્ય રીતે, દાખલ કરેલ ડેટા પર પ્રક્રિયા કરવામાં સૌથી વધુ સમય લાગે છે અને, જ્યાં સુધી હું જાણું છું, તે રમતનો ફ્રેમ દર નક્કી કરે છે. પરંતુ અહીં Logic() ફંક્શન ખૂબ જ ઝડપથી એક્ઝીક્યુટ થાય છે. તેથી, તમારે ગેમસ્પીડ પેરામીટર સાથે સ્લીપ() ફંક્શનનો ઉપયોગ કરીને ફ્રેમ રેટને નિયંત્રિત કરવો પડશે, જે આ ઝડપ નક્કી કરે છે.

રમત ચક્ર. નોટપેડમાં "સાપ" પ્રોગ્રામિંગ

જો તમે પાત્ર-આધારિત કન્સોલ રમત વિકસાવી રહ્યાં છો, તો તમે નિયમિત '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) માં આ ખામી નથી, કારણ કે ત્યાંનું આઉટપુટ વિવિધ રંગો સાથે સ્ક્રીન પિક્સેલને પેઇન્ટિંગ દ્વારા ગોઠવવામાં આવે છે. તમે કહી શકો કે મેં રેન્ડરર લખ્યું છે. સાચું, આ થોડું વધુ જટિલ છે, જો કે તે વધુ રસપ્રદ છે.

આ રમત માટે, સ્ક્રીન પર પિક્સેલ્સ પ્રદર્શિત કરવા માટે મારી સિસ્ટમનું વર્ણન કરવા માટે તે પૂરતું હશે. હું આને રમતનો મુખ્ય ભાગ માનું છું. અને તમે તમારી જાતને બાકીની દરેક વસ્તુ સાથે આવી શકો છો.

તેથી, તમે સ્ક્રીન પર જે જુઓ છો તે માત્ર ફરતા બહુ રંગીન લંબચોરસનો સમૂહ છે.

લંબચોરસનો સમૂહ

દરેક લંબચોરસને સંખ્યાઓથી ભરેલા મેટ્રિક્સ દ્વારા દર્શાવવામાં આવે છે. માર્ગ દ્વારા, હું એક રસપ્રદ ઉપદ્રવને પ્રકાશિત કરી શકું છું - રમતના તમામ મેટ્રિસિસ એક-પરિમાણીય એરે તરીકે પ્રોગ્રામ કરેલ છે. દ્વિ-પરિમાણીય નહીં, પરંતુ એક પરિમાણીય! એક-પરિમાણીય એરે સાથે કામ કરવા માટે ખૂબ સરળ અને ઝડપી છે.

ગેમ ટાંકી મેટ્રિક્સનું ઉદાહરણ

એક-પરિમાણીય એરે તરીકે રમત ટાંકી મેટ્રિક્સનું પ્રતિનિધિત્વ

મેટ્રિક્સને એક-પરિમાણીય અરે તરીકે રજૂ કરવાનું વધુ દ્રશ્ય ઉદાહરણ

પરંતુ એરેના ઘટકોની ઍક્સેસ ડબલ લૂપમાં થાય છે, જેમ કે તે એક-પરિમાણીય એરે નથી, પરંતુ દ્વિ-પરિમાણીય છે. આ કરવામાં આવ્યું છે કારણ કે અમે હજી પણ મેટ્રિસિસ સાથે કામ કરીએ છીએ.

ડબલ લૂપમાં એક-પરિમાણીય એરેને પસાર કરવું. Y - પંક્તિ ઓળખકર્તા, X - કૉલમ ઓળખકર્તા

મહેરબાની કરીને નોંધ કરો: સામાન્ય મેટ્રિક્સ ઓળખકર્તા i, j ને બદલે, હું x અને y ઓળખકર્તાઓનો ઉપયોગ કરું છું. આ રીતે, તે મને લાગે છે, તે આંખને વધુ આનંદદાયક અને મગજ માટે વધુ સમજી શકાય તેવું છે. વધુમાં, આવા સંકેત દ્વિ-પરિમાણીય છબીના સંકલન અક્ષો પર ઉપયોગમાં લેવાતા મેટ્રિસિસને અનુકૂળ રીતે પ્રોજેક્ટ કરવાનું શક્ય બનાવે છે.

હવે પિક્સેલ્સ, રંગ અને સ્ક્રીન આઉટપુટ વિશે. StretchDIBits ફંક્શનનો ઉપયોગ આઉટપુટ માટે થાય છે (હેડર: windows.h; લાઇબ્રેરી: gdi32.lib). આ ફંક્શન, અન્ય વસ્તુઓની સાથે, નીચે આપેલ પ્રાપ્ત કરે છે: ઉપકરણ કે જેના પર છબી પ્રદર્શિત થાય છે (મારા કિસ્સામાં, તે વિન્ડોઝ કન્સોલ છે), ઇમેજ ડિસ્પ્લેના પ્રારંભ કોઓર્ડિનેટ્સ, તેની પહોળાઈ/ઊંચાઈ અને છબી પોતે બીટમેપનું સ્વરૂપ, બાઇટ્સની એરે દ્વારા રજૂ થાય છે. બાઈટ એરે તરીકે બીટમેપ!

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 થી ઘેરા રાખોડી, વગેરેને અનુરૂપ છે. આમ, આપણે કહી શકીએ કે અમારી પાસે રમતના ક્ષેત્રનું મેટ્રિક્સ છે, જ્યાં દરેક સંખ્યા એક રંગ છે.

તેથી, અમારી પાસે એક બાજુએ સમગ્ર રમતના ક્ષેત્રનું આંકડાકીય મેટ્રિક્સ છે અને બીજી બાજુ છબી પ્રદર્શિત કરવા માટેનો બીટમેપ છે. અત્યાર સુધી, બીટમેપ "ખાલી" છે - તેમાં હજુ સુધી ઇચ્છિત રંગના પિક્સેલ્સ વિશેની માહિતી શામેલ નથી. આનો અર્થ એ છે કે છેલ્લું પગલું એ રમતના ક્ષેત્રના આંકડાકીય મેટ્રિક્સના આધારે દરેક પિક્સેલ વિશેની માહિતી સાથે બીટમેપને પોપ્યુલેટ કરવાનું હશે. આવા પરિવર્તનનું સ્પષ્ટ ઉદાહરણ નીચેના ચિત્રમાં છે.

રમતના ક્ષેત્રના ડિજિટલ મેટ્રિક્સ પર આધારિત માહિતી સાથે બીટમેપ (પિક્સેલ મેટ્રિક્સ) ભરવાનું ઉદાહરણ (રંગ સૂચકાંકો રમતના સૂચકાંકો સાથે મેળ ખાતા નથી)

હું રમતમાંથી વાસ્તવિક કોડનો એક ભાગ પણ રજૂ કરીશ. લૂપના દરેક પુનરાવૃત્તિ પરના વેરિયેબલ કલર ઈન્ડેક્સને રમતના ક્ષેત્ર (મુખ્ય ડિજિટલ મેટ્રિક્સ) ના આંકડાકીય મેટ્રિક્સમાંથી મૂલ્ય (રંગ અનુક્રમણિકા) અસાઇન કરવામાં આવે છે. કલર વેરીએબલ પછી ઇન્ડેક્સના આધારે રંગ પર સેટ કરવામાં આવે છે. પરિણામી રંગને પછી લાલ, લીલો અને વાદળી (RGB) ના ગુણોત્તરમાં વિભાજિત કરવામાં આવે છે. અને પિક્સેલપેડિંગ સાથે, આ માહિતીને પિક્સેલમાં વારંવાર લખવામાં આવે છે, જે બીટમેપમાં રંગીન ઈમેજ બનાવે છે.

કોડ પોઇન્ટર અને બીટવાઇઝ ઓપરેશન્સનો ઉપયોગ કરે છે, જેને સમજવું મુશ્કેલ હોઈ શકે છે. તેથી હું તમને ક્યાંક અલગથી વાંચવાની સલાહ આપીશ કે આવી રચનાઓ કેવી રીતે કાર્ય કરે છે.

રમતના ક્ષેત્રના આંકડાકીય મેટ્રિક્સ પર આધારિત માહિતી સાથે બીટમેપ ભરવા:

// 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 ગેમમાં ડ્રો() ફંક્શનમાં એક ચિત્ર (ફ્રેમ) બને છે અને સ્ક્રીન પર પ્રદર્શિત થાય છે. Input() ફંક્શનમાં કીસ્ટ્રોકની નોંધણી અને Logic() ફંક્શનમાં તેમની અનુગામી પ્રક્રિયા કર્યા પછી, એક નવું ચિત્ર (ફ્રેમ) રચાય છે. સાચું છે, રમતના ઑબ્જેક્ટ્સ પહેલેથી જ રમતના ક્ષેત્ર પર અલગ સ્થાન ધરાવે છે અને તે મુજબ, અલગ જગ્યાએ દોરવામાં આવે છે. આ રીતે એનિમેશન (ચળવળ) થાય છે.

સૈદ્ધાંતિક રીતે (જો હું કંઈપણ ભૂલી ન ગયો હોઉં), પ્રથમ રમત (“સાપ”) ના ગેમ લૂપને સમજવું અને બીજી રમત (“ટેન્ક્સ”) માંથી સ્ક્રીન પર પિક્સેલ્સ પ્રદર્શિત કરવા માટેની સિસ્ટમને સમજવા માટે તમારે કંઈપણ લખવાની જરૂર છે. Windows હેઠળ તમારી 2D રમતોમાંથી. અવાજહીન! 😉 બાકીના ભાગો માત્ર ફેન્સીની ફ્લાઇટ છે.

અલબત્ત, રમત "ટાંકીઓ" "સાપ" કરતા વધુ જટિલ છે. મેં પહેલેથી જ C++ ભાષાનો ઉપયોગ કર્યો છે, એટલે કે, મેં વર્ગો સાથે વિવિધ ગેમ ઑબ્જેક્ટ્સનું વર્ણન કર્યું છે. મેં મારો પોતાનો સંગ્રહ બનાવ્યો - કોડ હેડરો/Box.h માં જોઈ શકાય છે. માર્ગ દ્વારા, સંગ્રહમાં સંભવતઃ મેમરી લીક છે. વપરાયેલ નિર્દેશકો. મેમરી સાથે કામ કર્યું. મારે કહેવું જ જોઇએ કે પુસ્તકે મને ઘણી મદદ કરી ગેમ પ્રોગ્રામિંગ દ્વારા C++ ની શરૂઆત. C++ માં નવા નિશાળીયા માટે આ એક સરસ શરૂઆત છે. તે નાનું, રસપ્રદ અને સુવ્યવસ્થિત છે.

આ ગેમને વિકસાવવામાં લગભગ છ મહિનાનો સમય લાગ્યો હતો. મેં મુખ્યત્વે લંચ અને કામ પર નાસ્તા દરમિયાન લખ્યું. તેણે ઓફિસના રસોડામાં બેસીને ભોજનને કચડી નાખ્યું અને કોડ લખ્યો. અથવા ઘરે રાત્રિભોજન પર. તેથી હું આ "રસોડું યુદ્ધ" સાથે સમાપ્ત થયો. હંમેશની જેમ, મેં સક્રિયપણે એક નોટબુકનો ઉપયોગ કર્યો, અને તેમાં બધી વૈચારિક વસ્તુઓનો જન્મ થયો.

વ્યવહારુ ભાગ પૂર્ણ કરવા માટે, હું મારી નોટબુકના થોડા સ્કેન લઈશ. મેં બરાબર શું લખ્યું, દોર્યું, ગણ્યું, ડિઝાઇન કર્યું તે બતાવવા માટે...

ટાંકીઓની છબીઓ ડિઝાઇન કરવી. અને સ્ક્રીન પર દરેક ટાંકીએ કેટલા પિક્સેલ્સ કબજે કરવા જોઈએ તે નક્કી કરવું

તેની ધરીની આસપાસ ટાંકીના પરિભ્રમણ માટે અલ્ગોરિધમ અને સૂત્રોની ગણતરી

મારા સંગ્રહની યોજના (જેમાં મેમરી લીક છે, મોટે ભાગે). કલેક્શન લિંક્ડ લિસ્ટના પ્રકાર અનુસાર બનાવવામાં આવ્યું છે

અને આ રમત સાથે કૃત્રિમ બુદ્ધિમત્તાને જોડવાના નિરર્થક પ્રયાસો છે

થિયરી

"હજાર માઇલની મુસાફરી પણ પ્રથમ પગલાથી શરૂ થાય છે" (પ્રાચીન ચાઇનીઝ શાણપણ)

ચાલો પ્રેક્ટિસમાંથી સિદ્ધાંત તરફ આગળ વધીએ! તમારા શોખ માટે સમય કેવી રીતે શોધવો?

1. તમે ખરેખર શું ઇચ્છો છો તે નક્કી કરો (અરે, આ સૌથી મુશ્કેલ ભાગ છે).
2. પ્રાથમિકતાઓ સેટ કરો.
3. ઉચ્ચ પ્રાથમિકતાઓ માટે "અતિરિક્ત" બધું બલિદાન આપો.
4. દરરોજ લક્ષ્ય તરફ આગળ વધો.
5. કોઈ શોખ માટે બે કે ત્રણ કલાકનો મફત સમય પસાર કરવાની અપેક્ષા રાખશો નહીં.

એક તરફ, તમારે નક્કી કરવાની જરૂર છે કે તમે શું કરવા માંગો છો અને પ્રાથમિકતા આપો. બીજી બાજુ, આ પ્રાથમિકતાઓની તરફેણમાં કેટલીક પ્રવૃત્તિઓ/પ્રોજેક્ટોને છોડી દેવાનું શક્ય છે. બીજા શબ્દોમાં કહીએ તો, તમારે બધું "વધારાની" બલિદાન આપવું પડશે. મેં ક્યાંક સાંભળ્યું છે કે જીવનમાં વધુમાં વધુ ત્રણ મુખ્ય પ્રવૃત્તિઓ હોવી જોઈએ. પછી તમે તેમને ઉચ્ચતમ ગુણવત્તા પર કરી શકશો. અને વધારાના પ્રોજેક્ટ/દિશાઓ ખાલી ઓવરલોડ થવાનું શરૂ કરશે. પરંતુ આ બધું કદાચ વ્યક્તિલક્ષી અને વ્યક્તિગત છે.

ત્યાં એક ચોક્કસ સુવર્ણ નિયમ છે: ક્યારેય 0% દિવસ નથી! મેં તેના વિશે ઇન્ડી ડેવલપરના લેખમાં શીખ્યા. જો તમે કોઈ પ્રોજેક્ટ પર કામ કરી રહ્યા છો, તો તેના વિશે દરરોજ કંઈક કરો. અને તમે કેટલું કરો છો તેનાથી કોઈ ફરક પડતો નથી. એક શબ્દ અથવા કોડની એક લીટી લખો, એક ટ્યુટોરીયલ વિડિઓ જુઓ અથવા બોર્ડમાં એક ખીલી હથોડો - બસ કંઈક કરો. સૌથી મુશ્કેલ વસ્તુ શરૂ કરવી છે. એકવાર તમે પ્રારંભ કરો, પછી તમે સંભવતઃ તમે ઇચ્છતા કરતાં થોડું વધારે કરી શકશો. આ રીતે તમે સતત તમારા ધ્યેય તરફ આગળ વધશો અને, મારા પર વિશ્વાસ કરો, ખૂબ જ ઝડપથી. છેવટે, બધી બાબતોમાં મુખ્ય અવરોધ એ વિલંબ છે.

અને તે યાદ રાખવું અગત્યનું છે કે તમારે 5, 10, 15 મિનિટના સમયના મફત "લાગડાંપણ" ને ઓછો અંદાજ અને અવગણવો જોઈએ નહીં, એક કે બે કલાક સુધી ચાલતા કેટલાક મોટા "લોગ" માટે રાહ જુઓ. શું તમે લાઈનમાં ઉભા છો? તમારા પ્રોજેક્ટ માટે કંઈક વિશે વિચારો. એસ્કેલેટર લઈ રહ્યા છો? નોટપેડમાં કંઈક લખો. શું તમે બસમાં મુસાફરી કરો છો? સરસ, થોડો લેખ વાંચો. દરેક તકનો લાભ લો. YouTube પર બિલાડી અને કૂતરા જોવાનું બંધ કરો! તમારા મગજને પ્રદૂષિત કરશો નહીં!

અને એક છેલ્લી વાત. જો, આ લેખ વાંચ્યા પછી, તમને ગેમ એન્જિનનો ઉપયોગ કર્યા વિના ગેમ્સ બનાવવાનો વિચાર ગમ્યો હોય, તો પછી Casey Muratori નામ યાદ રાખો. આ વ્યક્તિ પાસે છે વેબસાઇટ. "ઘડિયાળ -> પહેલાના એપિસોડ" વિભાગમાં તમને શરૂઆતથી વ્યાવસાયિક રમત બનાવવા માટેના અદ્ભુત મફત વિડિઓ ટ્યુટોરિયલ્સ મળશે. વિન્ડોઝના પાઠ માટે પાંચ પ્રસ્તાવનામાં તમે યુનિવર્સિટીના પાંચ વર્ષના અભ્યાસ કરતાં વધુ શીખી શકશો (કોઈએ આ વિશે વિડિયો હેઠળની ટિપ્પણીઓમાં લખ્યું છે).

કેસી એ પણ સમજાવે છે કે તમારું પોતાનું ગેમ એન્જીન વિકસાવવાથી, તમે કોઈપણ હાલના એન્જિનની વધુ સારી સમજ મેળવશો. ફ્રેમવર્કની દુનિયામાં જ્યાં દરેક વ્યક્તિ સ્વચાલિત કરવાનો પ્રયાસ કરી રહી છે, તમે ઉપયોગ કરવાને બદલે બનાવવાનું શીખો છો. તમે કોમ્પ્યુટરના સ્વભાવને સમજો છો. અને તમે વધુ બુદ્ધિશાળી અને પરિપક્વ પ્રોગ્રામર પણ બનશો - એક પ્રો.

તમારા પસંદ કરેલા પાથ પર સારા નસીબ! અને ચાલો વિશ્વને વધુ વ્યાવસાયિક બનાવીએ.

લેખક: ગ્રાન્કિન એન્ડ્રી, DevOps

સોર્સ: www.habr.com