DevOps C++, "അടുക്കള യുദ്ധങ്ങൾ", അല്ലെങ്കിൽ ഭക്ഷണം കഴിക്കുമ്പോൾ ഞാൻ എങ്ങനെ ഗെയിമുകൾ എഴുതാൻ തുടങ്ങി

"എനിക്ക് ഒന്നും അറിയില്ലെന്ന് എനിക്കറിയാം" സോക്രട്ടീസ്

ആർക്ക്: എല്ലാ ഡെവലപ്പർമാരെയും തുപ്പുകയും അവരുടെ ഗെയിമുകൾ കളിക്കാൻ ആഗ്രഹിക്കുകയും ചെയ്യുന്ന ഐടി ആളുകൾക്ക്!

എന്തിനേക്കുറിച്ച്: നിങ്ങൾക്ക് ആവശ്യമെങ്കിൽ സി/സി++ ൽ ഗെയിമുകൾ എങ്ങനെ എഴുതാം!

എന്തുകൊണ്ടാണ് നിങ്ങൾ ഇത് വായിക്കേണ്ടത്: ആപ്പ് ഡെവലപ്‌മെന്റ് എന്റെ ജോലിയുടെ പ്രത്യേകതയല്ല, എന്നാൽ ഞാൻ എല്ലാ ആഴ്‌ചയും കോഡ് ചെയ്യാൻ ശ്രമിക്കുന്നു. കാരണം എനിക്ക് ഗെയിമുകൾ ഇഷ്ടമാണ്!

ഹലോ എന്റെ പേര് ആൻഡ്രി ഗ്രാൻകിൻ, ഞാൻ ലക്‌സോഫ്റ്റിലെ ഒരു DevOps ആണ്. ആപ്ലിക്കേഷൻ വികസനം എന്റെ ജോലിയുടെ പ്രത്യേകതയല്ല, എന്നാൽ എല്ലാ ആഴ്‌ചയും ഞാൻ കോഡ് ചെയ്യാൻ ശ്രമിക്കുന്നു. കാരണം എനിക്ക് ഗെയിമുകൾ ഇഷ്ടമാണ്!

കമ്പ്യൂട്ടർ ഗെയിം വ്യവസായം വളരെ വലുതാണ്, ഇന്ന് സിനിമാ വ്യവസായത്തേക്കാൾ കൂടുതൽ കിംവദന്തികളാണ്. ആധുനിക മാനദണ്ഡങ്ങൾ, സങ്കീർണ്ണവും അടിസ്ഥാനവുമായ വികസന രീതികൾ ഉപയോഗിച്ച് കമ്പ്യൂട്ടറുകളുടെ വികസനത്തിന്റെ തുടക്കം മുതൽ ഗെയിമുകൾ എഴുതിയിട്ടുണ്ട്. കാലക്രമേണ, ഇതിനകം പ്രോഗ്രാം ചെയ്ത ഗ്രാഫിക്സ്, ഫിസിക്സ്, ശബ്ദം എന്നിവ ഉപയോഗിച്ച് ഗെയിം എഞ്ചിനുകൾ പ്രത്യക്ഷപ്പെടാൻ തുടങ്ങി. ഗെയിമിന്റെ വികസനത്തിൽ തന്നെ ശ്രദ്ധ കേന്ദ്രീകരിക്കാനും അതിന്റെ അടിത്തറയെക്കുറിച്ച് വിഷമിക്കാതിരിക്കാനും അവ നിങ്ങളെ അനുവദിക്കുന്നു. എന്നാൽ അവരോടൊപ്പം, എഞ്ചിനുകൾക്കൊപ്പം, ഡവലപ്പർമാർ "അന്ധതയിലേക്ക് പോകുകയും" തരംതാഴ്ത്തുകയും ചെയ്യുന്നു. ഗെയിമുകളുടെ ഉത്പാദനം കൺവെയറിൽ സ്ഥാപിച്ചിരിക്കുന്നു. ഉൽപ്പാദനത്തിന്റെ അളവ് അതിന്റെ ഗുണനിലവാരത്തേക്കാൾ കൂടുതലായി തുടങ്ങുന്നു.

അതേ സമയം, മറ്റുള്ളവരുടെ ഗെയിമുകൾ കളിക്കുമ്പോൾ, മറ്റ് ആളുകൾ കൊണ്ടുവന്ന ലൊക്കേഷനുകൾ, പ്ലോട്ട്, കഥാപാത്രങ്ങൾ, ഗെയിം മെക്കാനിക്സ് എന്നിവയാൽ ഞങ്ങൾ നിരന്തരം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. അങ്ങനെ ഞാൻ അത് മനസ്സിലാക്കി...

… എനിക്ക് മാത്രം വിധേയമായി നിങ്ങളുടെ സ്വന്തം ലോകങ്ങൾ സൃഷ്ടിക്കാനുള്ള സമയമാണിത്. ഞാൻ പിതാവും പുത്രനും പരിശുദ്ധാത്മാവും ആയ ലോകങ്ങൾ!

നിങ്ങളുടെ സ്വന്തം ഗെയിം എഞ്ചിനും അതിൽ ഒരു ഗെയിമും എഴുതുന്നതിലൂടെ, നിങ്ങളുടെ കണ്ണുകൾ തുറക്കാനും വിൻഡോകൾ തുടയ്ക്കാനും നിങ്ങളുടെ ക്യാബിൻ പമ്പ് ചെയ്യാനും കൂടുതൽ പരിചയസമ്പന്നനും അവിഭാജ്യവുമായ പ്രോഗ്രാമർ ആകാൻ കഴിയുമെന്ന് ഞാൻ ആത്മാർത്ഥമായി വിശ്വസിക്കുന്നു.

ഈ ലേഖനത്തിൽ ഞാൻ സി / സി ++ ൽ ചെറിയ ഗെയിമുകൾ എങ്ങനെ എഴുതാൻ തുടങ്ങി, വികസന പ്രക്രിയ എന്താണ്, തിരക്കേറിയ അന്തരീക്ഷത്തിൽ ഒരു ഹോബിക്ക് ഞാൻ സമയം കണ്ടെത്തുന്നത് എങ്ങനെയെന്ന് നിങ്ങളോട് പറയാൻ ശ്രമിക്കും. ഇത് ആത്മനിഷ്ഠവും ഒരു വ്യക്തിഗത തുടക്കത്തിന്റെ പ്രക്രിയയെ വിവരിക്കുന്നു. അജ്ഞതയെയും വിശ്വാസത്തെയും കുറിച്ചുള്ള മെറ്റീരിയൽ, ഇപ്പോൾ ലോകത്തെക്കുറിച്ചുള്ള എന്റെ വ്യക്തിപരമായ ചിത്രത്തെ കുറിച്ച്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, "നിങ്ങളുടെ വ്യക്തിപരമായ തലച്ചോറിന് ഭരണകൂടം ഉത്തരവാദിയല്ല!".

പ്രാക്ടീസ് ചെയ്യുക

"അഭ്യാസമില്ലാത്ത അറിവ് ഉപയോഗശൂന്യമാണ്, അറിവില്ലാത്ത പരിശീലനം അപകടകരമാണ്." കൺഫ്യൂഷ്യസ്

എന്റെ നോട്ട്ബുക്കാണ് എന്റെ ജീവിതം!

അതിനാൽ, പ്രായോഗികമായി, എനിക്കുള്ളതെല്ലാം ഒരു നോട്ട്ബുക്കിൽ നിന്നാണ് ആരംഭിക്കുന്നതെന്ന് എനിക്ക് പറയാൻ കഴിയും. ഞാൻ അവിടെ എന്റെ ദൈനംദിന ജോലികൾ മാത്രമല്ല, വരയ്ക്കുക, പ്രോഗ്രാം ചെയ്യുക, ഫ്ലോചാർട്ടുകൾ രൂപകൽപ്പന ചെയ്യുക, ഗണിതശാസ്ത്രം ഉൾപ്പെടെയുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുക എന്നിവയും എഴുതുന്നു. എപ്പോഴും നോട്ട്പാഡ് ഉപയോഗിക്കുകയും പെൻസിൽ കൊണ്ട് മാത്രം എഴുതുകയും ചെയ്യുക. ഇത് വൃത്തിയുള്ളതും സൗകര്യപ്രദവും വിശ്വസനീയവുമാണ്, IMHO.

എന്റെ (ഇതിനകം പൂരിപ്പിച്ച) നോട്ട്ബുക്ക്. ഇത് ഇങ്ങനെയാണ്. ദൈനംദിന ജോലികൾ, ആശയങ്ങൾ, ഡ്രോയിംഗുകൾ, ഡയഗ്രമുകൾ, പരിഹാരങ്ങൾ, ബ്ലാക്ക് ബുക്ക് കീപ്പിംഗ്, കോഡ് തുടങ്ങിയവ ഇതിൽ അടങ്ങിയിരിക്കുന്നു.

ഈ ഘട്ടത്തിൽ, എനിക്ക് മൂന്ന് പ്രോജക്റ്റുകൾ പൂർത്തിയാക്കാൻ കഴിഞ്ഞു (ഇത് "ഫൈനൽ" എന്ന എന്റെ ധാരണയിലാണ്, കാരണം ഏത് ഉൽപ്പന്നവും താരതമ്യേന അനന്തമായി വികസിപ്പിക്കാൻ കഴിയും).

• പ്രോജക്റ്റ് 0: ഇത് യൂണിറ്റി ഗെയിം എഞ്ചിൻ ഉപയോഗിച്ച് C#-ൽ എഴുതിയ ഒരു ആർക്കിടെക്റ്റ് ഡെമോ 3D ദൃശ്യമാണ്. MacOS, Windows പ്ലാറ്റ്‌ഫോമുകൾക്കായി.
• ഗെയിം 1: വിൻഡോസിനായുള്ള കൺസോൾ ഗെയിം സിമ്പിൾ സ്നേക്ക് (എല്ലാവർക്കും "സ്നേക്ക്" എന്നാണ് അറിയപ്പെടുന്നത്). സിയിൽ എഴുതിയിരിക്കുന്നു.
• ഗെയിം 2: കൺസോൾ ഗെയിം ക്രേസി ടാങ്കുകൾ (എല്ലാവർക്കും "ടാങ്കുകൾ" എന്ന് അറിയപ്പെടുന്നു), ഇതിനകം C ++ (ക്ലാസുകൾ ഉപയോഗിച്ച്) കൂടാതെ വിൻഡോസിന് കീഴിലും എഴുതിയിരിക്കുന്നു.

പ്രോജക്റ്റ് 0 ആർക്കിടെക്റ്റ് ഡെമോ

• പ്ലാറ്റ്ഫോം: വിൻഡോസ് (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• ഭാഷ: C#
• ഗെയിം എഞ്ചിൻ: ഒത്തൊരുമ
• പ്രചോദനം: ഡാരിൻ ലീൽ
• സംഭരണിയാണ്: സാമൂഹികം

3D സീൻ ആർക്കിടെക്റ്റ് ഡെമോ

C/C++ യിലല്ല, C#-ൽ യൂണിറ്റി ഗെയിം എഞ്ചിൻ ഉപയോഗിച്ചാണ് ആദ്യ പദ്ധതി നടപ്പിലാക്കിയത്. ഈ എഞ്ചിൻ ഹാർഡ്‌വെയറിൽ ആവശ്യപ്പെടുന്നത് പോലെ ആയിരുന്നില്ല അൺറിയൽ എഞ്ചിൻ, കൂടാതെ ഇൻസ്റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും എനിക്ക് എളുപ്പമായി തോന്നി. മറ്റ് എഞ്ചിനുകൾ ഞാൻ പരിഗണിച്ചില്ല.

എന്നെ സംബന്ധിച്ചിടത്തോളം യൂണിറ്റിയിലെ ലക്ഷ്യം ഏതെങ്കിലും തരത്തിലുള്ള ഗെയിം വികസിപ്പിക്കുക എന്നതായിരുന്നില്ല. ഏതെങ്കിലും തരത്തിലുള്ള കഥാപാത്രങ്ങളുള്ള ഒരു 3D രംഗം സൃഷ്ടിക്കാൻ ഞാൻ ആഗ്രഹിച്ചു. അവൻ, അല്ലെങ്കിൽ അവൾ (ഞാൻ പ്രണയിച്ച പെൺകുട്ടിയെ ഞാൻ മാതൃകയാക്കി =) പുറം ലോകവുമായി നീങ്ങുകയും സംവദിക്കുകയും ചെയ്യേണ്ടതുണ്ട്. ഐക്യം എന്താണെന്നും വികസന പ്രക്രിയ എന്താണെന്നും എന്തെങ്കിലും സൃഷ്ടിക്കാൻ എത്രമാത്രം പരിശ്രമിക്കണമെന്നും മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. ആർക്കിടെക്റ്റ് ഡെമോ പ്രോജക്റ്റ് ജനിച്ചത് ഇങ്ങനെയാണ് (ഈ പേര് മിക്കവാറും ബുൾഷിറ്റിൽ നിന്ന് കണ്ടുപിടിച്ചതാണ്). പ്രോഗ്രാമിംഗ്, മോഡലിംഗ്, ആനിമേഷൻ, ടെക്‌സ്‌ചറിംഗ് എന്നിവ എനിക്ക് രണ്ട് മാസത്തെ ദൈനംദിന ജോലിയെടുത്തു.

3D മോഡലുകൾ എങ്ങനെ സൃഷ്ടിക്കാം എന്നതിനെക്കുറിച്ചുള്ള ട്യൂട്ടോറിയൽ വീഡിയോകൾ ഉപയോഗിച്ച് ഞാൻ YouTube-ൽ ആരംഭിച്ചു ബ്ലെൻഡർ. ഇൻസ്‌റ്റലേഷൻ ആവശ്യമില്ലാത്ത 3D മോഡലിംഗിനുള്ള (കൂടുതൽ കൂടുതൽ) മികച്ച സൗജന്യ ഉപകരണമാണ് ബ്ലെൻഡർ. ഇവിടെ ഒരു ഞെട്ടൽ എന്നെ കാത്തിരുന്നു ... മോഡലിംഗ്, ആനിമേഷൻ, ടെക്സ്ചറിംഗ് എന്നിവ നിങ്ങൾക്ക് പുസ്തകങ്ങൾ എഴുതാൻ കഴിയുന്ന വലിയ പ്രത്യേക വിഷയങ്ങളാണെന്ന് ഇത് മാറുന്നു. കഥാപാത്രങ്ങൾക്ക് ഇത് പ്രത്യേകിച്ച് സത്യമാണ്. വിരലുകൾ, പല്ലുകൾ, കണ്ണുകൾ, ശരീരത്തിന്റെ മറ്റ് ഭാഗങ്ങൾ എന്നിവ മാതൃകയാക്കാൻ, നിങ്ങൾക്ക് ശരീരഘടനയെക്കുറിച്ചുള്ള അറിവ് ആവശ്യമാണ്. മുഖത്തിന്റെ പേശികൾ എങ്ങനെയാണ് ക്രമീകരിച്ചിരിക്കുന്നത്? ആളുകൾ എങ്ങനെയാണ് നീങ്ങുന്നത്? ഓരോ കൈയിലും കാലിലും വിരലിലും നക്കിളിലും എനിക്ക് അസ്ഥികൾ "തിരുകണം"!

ക്ലാവിക്കിൾ, അധിക അസ്ഥി ലിവർ എന്നിവ മാതൃകയാക്കുക, അങ്ങനെ ആനിമേഷൻ സ്വാഭാവികമായി കാണപ്പെടുന്നു. അത്തരം പാഠങ്ങൾക്ക് ശേഷം, ആനിമേറ്റഡ് ഫിലിമുകളുടെ സ്രഷ്‌ടാക്കൾ 30 സെക്കൻഡ് വീഡിയോ സൃഷ്‌ടിക്കാൻ എത്ര വലിയ ജോലിയാണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നു. എന്നാൽ 3D സിനിമകൾ മണിക്കൂറുകൾ നീണ്ടുനിൽക്കും! എന്നിട്ട് ഞങ്ങൾ തിയേറ്ററുകളിൽ നിന്ന് പുറത്തിറങ്ങി ഇതുപോലെ എന്തെങ്കിലും പറയുന്നു: “ടാ, ഒരു മോശം കാർട്ടൂൺ / സിനിമ! അവർക്ക് ഇതിലും നന്നായി ചെയ്യാമായിരുന്നു..." വിഡ്ഢികളേ!

ഈ പ്രോജക്റ്റിലെ പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് ഒരു കാര്യം കൂടി. അത് മാറിയതുപോലെ, എനിക്ക് ഏറ്റവും രസകരമായ ഭാഗം ഗണിതശാസ്ത്രമായിരുന്നു. നിങ്ങൾ രംഗം പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ (പ്രോജക്റ്റ് വിവരണത്തിലെ ശേഖരത്തിലേക്കുള്ള ലിങ്ക്), ക്യാമറ ഒരു ഗോളത്തിൽ പെൺകുട്ടിയുടെ കഥാപാത്രത്തിന് ചുറ്റും കറങ്ങുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും. അത്തരമൊരു ക്യാമറ റൊട്ടേഷൻ പ്രോഗ്രാം ചെയ്യുന്നതിന്, ഞാൻ ആദ്യം സർക്കിളിലെ (2D) സ്ഥാന പോയിന്റിന്റെ കോർഡിനേറ്റുകൾ കണക്കാക്കേണ്ടതുണ്ട്, തുടർന്ന് ഗോളത്തിൽ (3D). സ്കൂളിൽ എനിക്ക് കണക്ക് വെറുപ്പായിരുന്നു, ഒരു മൈനസോടെ അത് അറിയാമായിരുന്നു എന്നതാണ് രസകരമായ കാര്യം. ഭാഗികമായി, ഒരുപക്ഷേ, ഈ ഗണിതശാസ്ത്രം ജീവിതത്തിൽ എങ്ങനെ പ്രയോഗിക്കുന്നുവെന്ന് സ്കൂളിൽ അവർ നിങ്ങളോട് വിശദീകരിക്കുന്നില്ല. എന്നാൽ നിങ്ങളുടെ ലക്ഷ്യം, സ്വപ്നം എന്നിവയിൽ നിങ്ങൾ അഭിനിവേശത്തിലാകുമ്പോൾ, മനസ്സ് ശുദ്ധമാകും, വെളിപ്പെടും! സങ്കീർണ്ണമായ ജോലികൾ ആവേശകരമായ സാഹസികതയായി നിങ്ങൾ മനസ്സിലാക്കാൻ തുടങ്ങുന്നു. എന്നിട്ട് നിങ്ങൾ ചിന്തിക്കുന്നു: "ശരി, *പ്രിയപ്പെട്ട* ഗണിതശാസ്‌ത്രജ്ഞന് ഈ സൂത്രവാക്യങ്ങൾ എവിടെയാണ് ചായാൻ കഴിയുക എന്ന് സാധാരണയായി പറയാൻ കഴിയാത്തത്?".

ഒരു വൃത്തത്തിലെയും ഗോളത്തിലെയും ഒരു ബിന്ദുവിന്റെ കോർഡിനേറ്റുകൾ കണക്കാക്കുന്നതിനുള്ള സൂത്രവാക്യങ്ങളുടെ കണക്കുകൂട്ടൽ (എന്റെ നോട്ട്ബുക്കിൽ നിന്ന്)

ഗെയിം 1

• പ്ലാറ്റ്ഫോം: വിൻഡോസ് (വിൻഡോസ് 7, 10-ൽ പരീക്ഷിച്ചു)
• ഭാഷ: ഇത് ശുദ്ധമായ സിയിൽ എഴുതിയതാണെന്ന് ഞാൻ കരുതുന്നു
• ഗെയിം എഞ്ചിൻ: വിൻഡോസ് കൺസോൾ
• പ്രചോദനം: javidx9
• സംഭരണിയാണ്: സാമൂഹികം

ലളിതമായ പാമ്പ് ഗെയിം

3D രംഗം ഒരു കളിയല്ല. കൂടാതെ, 3D ഒബ്‌ജക്‌റ്റുകൾ (പ്രത്യേകിച്ച് പ്രതീകങ്ങൾ) മോഡലിംഗും ആനിമേറ്റുചെയ്യലും ദൈർഘ്യമേറിയതും ബുദ്ധിമുട്ടുള്ളതുമാണ്. യൂണിറ്റിയുമായി കളിച്ചതിന് ശേഷം, എനിക്ക് അടിസ്ഥാനകാര്യങ്ങളിൽ നിന്ന് തുടരണം അല്ലെങ്കിൽ ആരംഭിക്കണമെന്ന് ഞാൻ മനസ്സിലാക്കി. ഗെയിമുകളുടെ ഘടന മനസ്സിലാക്കാൻ ലളിതവും വേഗതയേറിയതും എന്നാൽ അതേ സമയം ആഗോളവുമായ ഒന്ന്.

നമുക്ക് ലളിതവും വേഗതയേറിയതുമായ എന്താണുള്ളത്? അത് ശരിയാണ്, കൺസോളും 2Dയും. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, കൺസോളും ചിഹ്നങ്ങളും പോലും. വീണ്ടും, ഞാൻ ഇൻറർനെറ്റിൽ പ്രചോദനം തേടാൻ തുടങ്ങി (പൊതുവേ, XNUMX-ാം നൂറ്റാണ്ടിലെ ഏറ്റവും വിപ്ലവകരവും അപകടകരവുമായ കണ്ടുപിടുത്തമായി ഞാൻ ഇന്റർനെറ്റിനെ കരുതുന്നു). കൺസോൾ ടെട്രിസ് നിർമ്മിച്ച ഒരു പ്രോഗ്രാമറുടെ വീഡിയോ ഞാൻ കുഴിച്ചു. അവന്റെ കളിയുടെ സാദൃശ്യത്തിൽ, അവൻ "പാമ്പിനെ" വെട്ടിമാറ്റാൻ തീരുമാനിച്ചു. വീഡിയോയിൽ നിന്ന്, രണ്ട് അടിസ്ഥാന കാര്യങ്ങളെക്കുറിച്ച് ഞാൻ മനസ്സിലാക്കി - ഗെയിം ലൂപ്പ് (മൂന്ന് അടിസ്ഥാന പ്രവർത്തനങ്ങൾ / ഭാഗങ്ങൾ ഉള്ളത്), ബഫറിലേക്കുള്ള ഔട്ട്പുട്ട്.

ഗെയിം ലൂപ്പ് ഇതുപോലെയായിരിക്കാം:

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

കോഡ് മുഴുവൻ പ്രധാന() ഫംഗ്ഷനും ഒരേസമയം അവതരിപ്പിക്കുന്നു. അനുബന്ധ അഭിപ്രായത്തിന് ശേഷം ഗെയിം സൈക്കിൾ ആരംഭിക്കുന്നു. ലൂപ്പിൽ മൂന്ന് അടിസ്ഥാന പ്രവർത്തനങ്ങൾ ഉണ്ട്: ഇൻപുട്ട് (), ലോജിക് (), ഡ്രോ (). ആദ്യം, ഇൻപുട്ട് ഡാറ്റ ഇൻപുട്ട് (പ്രധാനമായും കീസ്‌ട്രോക്കുകളുടെ നിയന്ത്രണം), തുടർന്ന് നൽകിയ ഡാറ്റ ലോജിക് പ്രോസസ്സ് ചെയ്യുന്നു, തുടർന്ന് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നു - വരയ്ക്കുക. അങ്ങനെ ഓരോ ഫ്രെയിമും. ആനിമേഷൻ ഈ രീതിയിൽ സൃഷ്ടിക്കപ്പെടുന്നു. ഇത് കാർട്ടൂൺ പോലെയാണ്. സാധാരണയായി ഇൻപുട്ട് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഏറ്റവും കൂടുതൽ സമയമെടുക്കും, എനിക്കറിയാവുന്നിടത്തോളം, ഗെയിമിന്റെ ഫ്രെയിം റേറ്റ് നിർണ്ണയിക്കുന്നു. എന്നാൽ ഇവിടെ ലോജിക്() ഫംഗ്ഷൻ വളരെ വേഗതയുള്ളതാണ്. അതിനാൽ, ഈ നിരക്ക് നിർണ്ണയിക്കുന്ന ഗെയിംസ്പീഡ് പാരാമീറ്റർ ഉപയോഗിച്ച് സ്ലീപ്പ് () ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഫ്രെയിം റേറ്റ് നിയന്ത്രിക്കണം.

ഗെയിം സൈക്കിൾ. നോട്ട്പാഡിൽ സ്നേക്ക് പ്രോഗ്രാമിംഗ്

നിങ്ങൾ ഒരു പ്രതീകാത്മക കൺസോൾ ഗെയിം വികസിപ്പിക്കുകയാണെങ്കിൽ, സാധാരണ സ്ട്രീം ഔട്ട്പുട്ട് 'കൗട്ട്' ഉപയോഗിച്ച് സ്ക്രീനിൽ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നത് പ്രവർത്തിക്കില്ല - ഇത് വളരെ മന്ദഗതിയിലാണ്. അതിനാൽ, ഔട്ട്പുട്ട് സ്ക്രീൻ ബഫറിൽ നടത്തണം. വളരെ വേഗത്തിൽ, കളി തടസ്സങ്ങളില്ലാതെ പ്രവർത്തിക്കും. സത്യം പറഞ്ഞാൽ, സ്‌ക്രീൻ ബഫർ എന്താണെന്നും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും എനിക്ക് തീരെ മനസ്സിലാകുന്നില്ല. എന്നാൽ ഞാൻ ഇവിടെ ഒരു കോഡ് ഉദാഹരണം നൽകും, ഒരുപക്ഷേ അഭിപ്രായങ്ങളിൽ ആർക്കെങ്കിലും സാഹചര്യം വ്യക്തമാക്കാൻ കഴിയും.

സ്ക്രീൻ ബഫർ നേടുന്നു (ഞാൻ അങ്ങനെ പറഞ്ഞാൽ):

// 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-ൽ പരീക്ഷിച്ചു)
• ഭാഷ: സി ++
• ഗെയിം എഞ്ചിൻ: വിൻഡോസ് കൺസോൾ
• പ്രചോദനം: ഒരു പുസ്തകം ഗെയിം പ്രോഗ്രാമിംഗിലൂടെ സി++ ആരംഭിക്കുന്നു
• സംഭരണിയാണ്: സാമൂഹികം

ക്രേസി ടാങ്ക് ഗെയിം

കൺസോളിലേക്ക് പ്രതീകങ്ങൾ അച്ചടിക്കുന്നത് ഒരുപക്ഷേ നിങ്ങൾക്ക് ഒരു ഗെയിമായി മാറാൻ കഴിയുന്ന ഏറ്റവും ലളിതമായ കാര്യമാണ്. എന്നാൽ ഒരു കുഴപ്പം പ്രത്യക്ഷപ്പെടുന്നു: പ്രതീകങ്ങൾക്ക് വ്യത്യസ്ത ഉയരങ്ങളും വീതിയും ഉണ്ട് (ഉയരം വീതിയേക്കാൾ വലുതാണ്). അങ്ങനെ, എല്ലാം ആനുപാതികമല്ലാത്തതായി കാണപ്പെടും, താഴേക്കോ മുകളിലേക്കോ നീങ്ങുന്നത് ഇടത്തോട്ടോ വലത്തോട്ടോ നീങ്ങുന്നതിനേക്കാൾ വളരെ വേഗത്തിൽ തോന്നും. ഈ പ്രഭാവം "സ്നേക്ക്" (ഗെയിം 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 പിക്സലാണ്. ചുവപ്പ് മൂല്യത്തിന് ഒരു ബൈറ്റ്, പച്ച മൂല്യത്തിന് (ജി) ഒരു ബൈറ്റ്, നീല നിറത്തിന് (ബി) ഒരു ബൈറ്റ്. കൂടാതെ, ഓരോ ഇൻഡന്റിലും ഒരു ബൈറ്റ് ഉണ്ട്. ഈ മൂന്ന് നിറങ്ങൾ - ചുവപ്പ് / പച്ച / നീല (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;
   }

മുകളിൽ വിവരിച്ച രീതി അനുസരിച്ച്, ക്രേസി ടാങ്ക് ഗെയിമിൽ ഒരു ചിത്രം (ഫ്രെയിം) രൂപീകരിക്കുകയും ഡ്രോ () ഫംഗ്ഷനിൽ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ഇൻപുട്ട് () ഫംഗ്‌ഷനിൽ കീസ്‌ട്രോക്കുകൾ രജിസ്റ്റർ ചെയ്‌തതിനും ലോജിക് () ഫംഗ്‌ഷനിൽ അവയുടെ തുടർന്നുള്ള പ്രോസസ്സിംഗിനും ശേഷം, ഒരു പുതിയ ചിത്രം (ഫ്രെയിം) രൂപം കൊള്ളുന്നു. ശരിയാണ്, ഗെയിം ഒബ്‌ജക്റ്റുകൾക്ക് ഇതിനകം കളിക്കളത്തിൽ വ്യത്യസ്ത സ്ഥാനം ഉണ്ടായിരിക്കാം, അതനുസരിച്ച്, മറ്റൊരു സ്ഥലത്ത് വരച്ചിരിക്കുന്നു. ഇങ്ങനെയാണ് ആനിമേഷൻ (ചലനം) സംഭവിക്കുന്നത്.

സിദ്ധാന്തത്തിൽ (നിങ്ങൾ ഒന്നും മറന്നിട്ടില്ലെങ്കിൽ), ആദ്യ ഗെയിമിൽ നിന്നുള്ള ഗെയിം ലൂപ്പും (“സ്നേക്ക്”) രണ്ടാമത്തെ ഗെയിമിൽ നിന്ന് (“ടാങ്കുകൾ”) സ്ക്രീനിൽ പിക്സലുകൾ പ്രദർശിപ്പിക്കുന്നതിനുള്ള സംവിധാനവും (“ടാങ്കുകൾ”) മനസിലാക്കുക. Windows-നുള്ള നിങ്ങളുടെ 2D ഗെയിമുകൾ. ശബ്ദരഹിതം! 😉 ബാക്കി ഭാഗങ്ങൾ വെറും ഫാൻസി ആണ്.

തീർച്ചയായും, "ടാങ്കുകൾ" എന്ന ഗെയിം "സ്നേക്ക്" എന്നതിനേക്കാൾ വളരെ സങ്കീർണ്ണമാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഞാൻ ഇതിനകം C ++ ഭാഷ ഉപയോഗിച്ചു, അതായത്, ക്ലാസുകൾക്കൊപ്പം വ്യത്യസ്ത ഗെയിം ഒബ്ജക്റ്റുകളെ ഞാൻ വിവരിച്ചു. ഞാൻ എന്റെ സ്വന്തം ശേഖരം സൃഷ്ടിച്ചു - നിങ്ങൾക്ക് കോഡ് ഹെഡ്ഡറുകൾ/Box.h-ൽ കാണാൻ കഴിയും. വഴിയിൽ, ശേഖരത്തിന് മിക്കവാറും മെമ്മറി ലീക്ക് ഉണ്ട്. ഉപയോഗിച്ച പോയിന്ററുകൾ. മെമ്മറി ഉപയോഗിച്ച് പ്രവർത്തിച്ചു. പുസ്തകം എന്നെ വളരെയധികം സഹായിച്ചു എന്ന് ഞാൻ പറയണം. ഗെയിം പ്രോഗ്രാമിംഗിലൂടെ സി++ ആരംഭിക്കുന്നു. C++ ലെ തുടക്കക്കാർക്ക് ഇതൊരു മികച്ച തുടക്കമാണ്. ഇത് ചെറുതും രസകരവും നന്നായി ചിട്ടപ്പെടുത്തിയതുമാണ്.

ഈ ഗെയിം വികസിപ്പിക്കാൻ ഏകദേശം ആറ് മാസമെടുത്തു. ഞാൻ പ്രധാനമായും ഉച്ചഭക്ഷണ സമയത്തും ജോലിസ്ഥലത്ത് ലഘുഭക്ഷണ സമയത്തും എഴുതി. അവൻ ഓഫീസിലെ അടുക്കളയിൽ ഇരുന്നു ഭക്ഷണം ചവിട്ടി കോഡ് എഴുതി. അല്ലെങ്കിൽ അത്താഴത്തിന് വീട്ടിൽ. അതിനാൽ എനിക്ക് അത്തരം "അടുക്കള യുദ്ധങ്ങൾ" ലഭിച്ചു. എല്ലായ്പ്പോഴും എന്നപോലെ, ഞാൻ ഒരു നോട്ട്ബുക്ക് സജീവമായി ഉപയോഗിച്ചു, എല്ലാ ആശയപരമായ കാര്യങ്ങളും അതിൽ ജനിച്ചു.

പ്രായോഗിക ഭാഗത്തിന്റെ അവസാനം, ഞാൻ എന്റെ നോട്ട്ബുക്കിന്റെ കുറച്ച് സ്കാനുകൾ പുറത്തെടുക്കും. ഞാൻ കൃത്യമായി എന്താണ് എഴുതുന്നതെന്ന് കാണിക്കാൻ, വരയ്ക്കുക, എണ്ണുക, ഡിസൈൻ ചെയ്യുക...

ടാങ്ക് ഇമേജ് ഡിസൈൻ. ഓരോ ടാങ്കും സ്ക്രീനിൽ എത്ര പിക്സലുകൾ ഉൾക്കൊള്ളണം എന്നതിന്റെ നിർവ്വചനം

അതിന്റെ അച്ചുതണ്ടിന് ചുറ്റുമുള്ള ടാങ്കിന്റെ ഭ്രമണത്തിനായുള്ള അൽഗോരിതം, സൂത്രവാക്യങ്ങൾ എന്നിവയുടെ കണക്കുകൂട്ടൽ

എന്റെ ശേഖരത്തിന്റെ ഡയഗ്രം (മെമ്മറി ലീക്ക് ഉള്ളത്, മിക്കവാറും). ശേഖരം ഒരു ലിങ്ക്ഡ് ലിസ്റ്റായി സൃഷ്ടിച്ചിരിക്കുന്നു

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസിനെ ഗെയിമിലേക്ക് തിരുകിക്കയറ്റാനുള്ള വ്യർത്ഥമായ ശ്രമങ്ങളാണിവ

സിദ്ധാന്തം

"ആയിരം മൈൽ യാത്ര പോലും ആരംഭിക്കുന്നത് ആദ്യപടിയിൽ നിന്നാണ്" (പുരാതന ചൈനീസ് ജ്ഞാനം)

നമുക്ക് പരിശീലനത്തിൽ നിന്ന് സിദ്ധാന്തത്തിലേക്ക് പോകാം! നിങ്ങളുടെ ഹോബിക്ക് എങ്ങനെ സമയം കണ്ടെത്താം?

1. നിങ്ങൾക്ക് ശരിക്കും എന്താണ് വേണ്ടതെന്ന് നിർണ്ണയിക്കുക (അയ്യോ, ഇത് ഏറ്റവും ബുദ്ധിമുട്ടാണ്).
2. മുൻഗണനകൾ നിശ്ചയിക്കുക.
3. ഉയർന്ന മുൻഗണനകൾക്കായി എല്ലാ "അധികവും" ത്യജിക്കുക.
4. എല്ലാ ദിവസവും നിങ്ങളുടെ ലക്ഷ്യങ്ങളിലേക്ക് നീങ്ങുക.
5. ഒരു ഹോബിക്കായി രണ്ടോ മൂന്നോ മണിക്കൂർ സൗജന്യ സമയം ഉണ്ടാകുമെന്ന് പ്രതീക്ഷിക്കരുത്.

ഒരു വശത്ത്, നിങ്ങൾക്ക് എന്താണ് വേണ്ടതെന്ന് നിർണ്ണയിക്കുകയും മുൻഗണന നൽകുകയും വേണം. മറുവശത്ത്, ഈ മുൻഗണനകൾക്ക് അനുകൂലമായി ചില കേസുകൾ / പ്രോജക്റ്റുകൾ ഉപേക്ഷിക്കാൻ കഴിയും. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, "അമിതമായ" എല്ലാം നിങ്ങൾ ത്യജിക്കേണ്ടിവരും. ജീവിതത്തിൽ പരമാവധി മൂന്ന് പ്രധാന പ്രവർത്തനങ്ങൾ വേണമെന്ന് എവിടെയോ കേട്ടിട്ടുണ്ട്. അപ്പോൾ നിങ്ങൾക്ക് അവരെ ഏറ്റവും മികച്ച രീതിയിൽ കൈകാര്യം ചെയ്യാൻ കഴിയും. കൂടാതെ അധിക പ്രോജക്ടുകൾ/ദിശകൾ ഓവർലോഡ് ചെയ്യാൻ തുടങ്ങും. എന്നാൽ ഇതെല്ലാം, ഒരുപക്ഷേ, ആത്മനിഷ്ഠവും വ്യക്തിഗതവുമാണ്.

ഒരു നിശ്ചിത സുവർണ്ണ നിയമമുണ്ട്: ഒരിക്കലും 0% ദിവസം പാടില്ല! ഒരു ഇൻഡി ഡെവലപ്പറുടെ ഒരു ലേഖനത്തിൽ ഞാൻ അതിനെക്കുറിച്ച് മനസ്സിലാക്കി. നിങ്ങൾ ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുകയാണെങ്കിൽ, എല്ലാ ദിവസവും അതിനെക്കുറിച്ച് എന്തെങ്കിലും ചെയ്യുക. പിന്നെ എത്ര ഉണ്ടാക്കിയാലും കാര്യമില്ല. ഒരു വാക്കോ കോഡിന്റെ ഒരു വരിയോ എഴുതുക, ഒരു ട്യൂട്ടോറിയൽ വീഡിയോ കാണുക, അല്ലെങ്കിൽ ബോർഡിൽ ഒരു ആണി അടിക്കുക-എന്തെങ്കിലും ചെയ്യുക. ഏറ്റവും ബുദ്ധിമുട്ടുള്ള ഭാഗം ആരംഭിക്കുകയാണ്. നിങ്ങൾ ആരംഭിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾ ആഗ്രഹിച്ചതിലും അൽപ്പം കൂടുതൽ നിങ്ങൾ ചെയ്യും. അതിനാൽ നിങ്ങൾ നിരന്തരം നിങ്ങളുടെ ലക്ഷ്യത്തിലേക്ക് നീങ്ങും, എന്നെ വിശ്വസിക്കൂ, വളരെ വേഗത്തിൽ. എല്ലാത്തിനുമുപരി, എല്ലാ കാര്യങ്ങളുടെയും പ്രധാന ബ്രേക്ക് നീട്ടിവെക്കലാണ്.

5, 10, 15 മിനിറ്റിനുള്ളിൽ നിങ്ങൾ സമയത്തിന്റെ സൌജന്യ " മാത്രമാവില്ല" യെ കുറച്ചുകാണുകയും അവഗണിക്കുകയും ചെയ്യരുതെന്ന് ഓർമ്മിക്കേണ്ടത് പ്രധാനമാണ്, ഒന്നോ രണ്ടോ മണിക്കൂർ നീണ്ടുനിൽക്കുന്ന ചില വലിയ "ലോഗുകൾ"ക്കായി കാത്തിരിക്കുക. നിങ്ങൾ വരിയിൽ നിൽക്കുന്നുണ്ടോ? നിങ്ങളുടെ പ്രോജക്റ്റിനായി എന്തെങ്കിലും ചിന്തിക്കുക. നിങ്ങൾ എസ്കലേറ്ററിൽ കയറുകയാണോ? ഒരു നോട്ട്ബുക്കിൽ എന്തെങ്കിലും എഴുതുക. നിങ്ങൾ ബസിൽ ഭക്ഷണം കഴിക്കാറുണ്ടോ? ശരി, കുറച്ച് ലേഖനം വായിക്കുക. എല്ലാ അവസരങ്ങളും ഉപയോഗിക്കുക. YouTube-ൽ പൂച്ചകളെയും നായ്ക്കളെയും കാണുന്നത് നിർത്തുക! നിങ്ങളുടെ മസ്തിഷ്കത്തിൽ കുഴപ്പമുണ്ടാക്കരുത്!

അവസാനത്തേതും. ഈ ലേഖനം വായിച്ചതിനുശേഷം, ഗെയിം എഞ്ചിനുകൾ ഉപയോഗിക്കാതെ ഗെയിമുകൾ സൃഷ്ടിക്കുക എന്ന ആശയം നിങ്ങൾക്ക് ഇഷ്ടപ്പെട്ടെങ്കിൽ, കേസി മുറേറ്റോറി എന്ന പേര് ഓർക്കുക. ഈ ആളുണ്ട് വെബ്സൈറ്റ്. "വാച്ച് -> മുൻ എപ്പിസോഡുകൾ" വിഭാഗത്തിൽ ആദ്യം മുതൽ ഒരു പ്രൊഫഷണൽ ഗെയിം എങ്ങനെ സൃഷ്ടിക്കാം എന്നതിനെക്കുറിച്ചുള്ള അതിശയകരമായ സൗജന്യ വീഡിയോ ട്യൂട്ടോറിയലുകൾ നിങ്ങൾ കണ്ടെത്തും. യൂണിവേഴ്സിറ്റിയിലെ അഞ്ച് വർഷത്തെ പഠനത്തേക്കാൾ വിൻഡോസ് പാഠങ്ങൾക്കായി അഞ്ച് ആമുഖം മുതൽ സി വരെ നിങ്ങൾക്ക് കൂടുതൽ പഠിക്കാം (വീഡിയോയ്ക്ക് താഴെയുള്ള അഭിപ്രായങ്ങളിൽ ആരോ ഇതിനെക്കുറിച്ച് എഴുതി).

നിങ്ങളുടെ സ്വന്തം ഗെയിം എഞ്ചിൻ വികസിപ്പിച്ചെടുക്കുന്നതിലൂടെ, നിലവിലുള്ള എഞ്ചിനുകളെ കുറിച്ച് നിങ്ങൾക്ക് നന്നായി മനസ്സിലാക്കാൻ കഴിയുമെന്നും കേസി വിശദീകരിക്കുന്നു. എല്ലാവരും ഓട്ടോമേറ്റ് ചെയ്യാൻ ശ്രമിക്കുന്ന ചട്ടക്കൂടുകളുടെ ലോകത്ത്, എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും, ഉപയോഗിക്കരുത്. കമ്പ്യൂട്ടറുകളുടെ സ്വഭാവം മനസ്സിലാക്കുക. കൂടാതെ നിങ്ങൾ കൂടുതൽ ബുദ്ധിമാനും പക്വതയുള്ളതുമായ ഒരു പ്രോഗ്രാമർ ആകും - ഒരു പ്രോ.

നിങ്ങൾ തിരഞ്ഞെടുത്ത പാതയിൽ ഭാഗ്യം! ലോകത്തെ കൂടുതൽ പ്രൊഫഷണലാക്കാം.

രചയിതാവ്: ഗ്രാൻകിൻ ആൻഡ്രി, DevOps

അവലംബം: www.habr.com