DevOps C++ మరియు "వంటగది యుద్ధాలు" లేదా నేను తినేటప్పుడు గేమ్‌లు రాయడం ఎలా ప్రారంభించాను

"నాకు ఏమీ తెలియదని నాకు తెలుసు" సోక్రటీస్

ఎవరికీ: డెవలపర్‌లందరి గురించి పట్టించుకోని మరియు వారి ఆటలను ఆడాలనుకునే IT వ్యక్తుల కోసం!

దేని గురించి: మీకు అకస్మాత్తుగా అవసరమైతే C/C++లో గేమ్‌లు రాయడం ఎలా అనే దాని గురించి!

మీరు దీన్ని ఎందుకు చదవాలి: అప్లికేషన్ అభివృద్ధి అనేది నా నైపుణ్యం యొక్క ప్రాంతం కాదు, కానీ నేను ప్రతి వారం కోడ్ చేయడానికి ప్రయత్నిస్తాను. ఎందుకంటే నాకు ఆటలంటే చాలా ఇష్టం!

నమస్తే నా పేరు ఆండ్రీ గ్రాంకిన్, నేను Luxoftలో DevOpsని. అప్లికేషన్ డెవలప్‌మెంట్ నా ప్రత్యేకత కాదు, కానీ నేను ప్రతి వారం కోడ్ చేయడానికి ప్రయత్నిస్తాను. ఎందుకంటే నాకు ఆటలంటే చాలా ఇష్టం!

కంప్యూటర్ గేమింగ్ పరిశ్రమ చాలా పెద్దది, ఈ రోజు చలనచిత్ర పరిశ్రమ కంటే పెద్దదిగా పుకార్లు ఉన్నాయి. ఆధునిక ప్రమాణాలు, సంక్లిష్టమైన మరియు ప్రాథమిక అభివృద్ధి పద్ధతులను ఉపయోగించి, కంప్యూటర్లు ప్రారంభమైనప్పటి నుండి ఆటలు వ్రాయబడ్డాయి. కాలక్రమేణా, ఇప్పటికే ప్రోగ్రామ్ చేయబడిన గ్రాఫిక్స్, ఫిజిక్స్ మరియు ధ్వనితో గేమ్ ఇంజన్లు కనిపించడం ప్రారంభించాయి. ఆటను అభివృద్ధి చేయడంపై దృష్టి పెట్టడానికి మరియు దాని పునాది గురించి చింతించకుండా అవి మిమ్మల్ని అనుమతిస్తాయి. కానీ వారితో పాటు, ఇంజిన్లతో, డెవలపర్లు "బ్లైండ్" మరియు అధోకరణం చెందుతారు. ఆటల ఉత్పత్తిని కన్వేయర్ బెల్ట్‌పై ఉంచారు. మరియు ఉత్పత్తుల పరిమాణం దాని నాణ్యతపై ప్రబలంగా ప్రారంభమవుతుంది.

అదే సమయంలో, ఇతర వ్యక్తుల ఆటలను ఆడుతున్నప్పుడు, ఇతర వ్యక్తులు రూపొందించిన స్థానాలు, ప్లాట్లు, పాత్రలు మరియు గేమ్ మెకానిక్‌ల ద్వారా మేము నిరంతరం పరిమితం అవుతాము. కాబట్టి నేను దానిని గ్రహించాను ...

... నాకు మాత్రమే లోబడి నా స్వంత ప్రపంచాలను సృష్టించే సమయం వచ్చింది. నేను తండ్రి, కుమారుడు మరియు పవిత్రాత్మగా ఉన్న ప్రపంచాలు!

మరియు మీ స్వంత గేమ్ ఇంజిన్‌ని వ్రాసి, దానిపై ఆడటం ద్వారా, మీరు మీ బూట్లను తీసివేసి, కిటికీలను తుడిచి, మీ క్యాబిన్‌ను అప్‌గ్రేడ్ చేయగలరని, మరింత అనుభవజ్ఞుడైన మరియు పూర్తి ప్రోగ్రామర్‌గా మారగలరని నేను హృదయపూర్వకంగా నమ్ముతున్నాను.

ఈ ఆర్టికల్‌లో నేను సి/సి++లో చిన్న చిన్న గేమ్‌లు ఎలా రాయడం ప్రారంభించాను, డెవలప్‌మెంట్ ప్రాసెస్ ఎలా ఉంది మరియు బిజీ వాతావరణంలో హాబీకి ఎక్కడ సమయం దొరుకుతుందో చెప్పడానికి ప్రయత్నిస్తాను. ఇది ఆత్మాశ్రయమైనది మరియు వ్యక్తిగత ప్రారంభ ప్రక్రియను వివరిస్తుంది. అజ్ఞానం మరియు విశ్వాసం గురించిన మెటీరియల్, ప్రస్తుతానికి ప్రపంచం గురించి నా వ్యక్తిగత చిత్రం గురించి. మరో మాటలో చెప్పాలంటే, "మీ వ్యక్తిగత మెదడుకు పరిపాలన బాధ్యత వహించదు!"

ఆచరణలో

"అభ్యాసం లేని జ్ఞానం పనికిరానిది, జ్ఞానం లేని అభ్యాసం ప్రమాదకరం" కన్ఫ్యూషియస్

నా నోట్బుక్ నా జీవితం!

కాబట్టి, ఆచరణలో, నాకు ప్రతిదీ నోట్‌ప్యాడ్‌తో మొదలవుతుందని నేను చెప్పగలను. నేను నా రోజువారీ పనులను అక్కడ వ్రాయడమే కాదు, నేను గణితంతో సహా ఫ్లోచార్ట్‌లను గీయడం, ప్రోగ్రామ్ చేయడం, డిజైన్ చేయడం మరియు సమస్యలను పరిష్కరిస్తాను. ఎల్లప్పుడూ నోట్‌ప్యాడ్‌ని ఉపయోగించండి మరియు పెన్సిల్‌లో మాత్రమే వ్రాయండి. ఇది శుభ్రంగా, అనుకూలమైనది మరియు నమ్మదగినది, IMHO.

నా (ఇప్పటికే నిండి ఉంది) నోట్‌బుక్. అతను ఇలా కనిపిస్తున్నాడు. ఇది రోజువారీ పనులు, ఆలోచనలు, డ్రాయింగ్‌లు, రేఖాచిత్రాలు, పరిష్కారాలు, బ్లాక్ బుక్ కీపింగ్, కోడ్ మొదలైనవాటిని కలిగి ఉంటుంది

ఈ దశలో, నేను మూడు ప్రాజెక్ట్‌లను పూర్తి చేయగలిగాను (ఇది “సంపూర్ణత” గురించి నా అవగాహనలో ఉంది, ఎందుకంటే ఏదైనా ఉత్పత్తి సాపేక్షంగా అనంతంగా అభివృద్ధి చెందుతుంది).

• ప్రాజెక్ట్ 0: ఇది యూనిటీ గేమ్ ఇంజిన్‌ని ఉపయోగించి C#లో వ్రాసిన 3D ఆర్కిటెక్ట్ డెమో దృశ్యం. MacOS మరియు Windows ప్లాట్‌ఫారమ్‌ల కోసం.
• గేమ్ 1: Windows కోసం కన్సోల్ గేమ్ సింపుల్ స్నేక్ (అందరికీ "స్నేక్" అని పిలుస్తారు). సి లో వ్రాయబడింది.
• గేమ్ 2: కన్సోల్ గేమ్ క్రేజీ ట్యాంకులు (అందరికీ "ట్యాంక్స్" అని పిలుస్తారు), C++ (తరగతులు ఉపయోగించి) మరియు Windows కోసం కూడా వ్రాయబడింది.

ప్రాజెక్ట్ 0. ఆర్కిటెక్ట్ డెమో

• వేదిక: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• భాష: C#
• గేమ్ ఇంజిన్: యూనిటీ
• ప్రేరణ: డారిన్ లిలే
• రిపోజిటరీ: గ్యాలరీలు

3D సీన్ ఆర్కిటెక్ట్ డెమో

మొదటి ప్రాజెక్ట్ C/C++లో కాకుండా యూనిటీ గేమ్ ఇంజిన్‌ని ఉపయోగించి C#లో అమలు చేయబడింది. ఈ ఇంజిన్ హార్డ్‌వేర్‌పై అంత డిమాండ్ లేదు అన్రియల్ ఇంజిన్, మరియు ఇన్‌స్టాల్ చేయడం మరియు ఉపయోగించడం కూడా సులభం అనిపించింది. నేను ఇతర ఇంజిన్‌లను పరిగణించలేదు.

ఐక్యతలో నా లక్ష్యం ఆటను అభివృద్ధి చేయడం కాదు. నేను ఏదో ఒక పాత్రతో 3డి సన్నివేశాన్ని రూపొందించాలనుకున్నాను. అతను లేదా బదులుగా ఆమె (నేను ప్రేమలో ఉన్న అమ్మాయిని నేను మోడల్ చేసాను =) అతని చుట్టూ ఉన్న ప్రపంచంతో కదలాలి మరియు సంభాషించాలి. ఐక్యత అంటే ఏమిటి, అభివృద్ధి ప్రక్రియ ఏమిటి మరియు ఏదైనా సృష్టించడానికి ఎంత ప్రయత్నం అవసరమో అర్థం చేసుకోవడం మాత్రమే ముఖ్యం. ఆర్కిటెక్ట్ డెమో ప్రాజెక్ట్ ఈ విధంగా పుట్టింది (పేరు దాదాపు ఎక్కడా కనుగొనబడలేదు). ప్రోగ్రామింగ్, మోడలింగ్, యానిమేషన్, టెక్స్చరింగ్ నాకు బహుశా రెండు నెలల రోజువారీ పని పట్టింది.

నేను 3D మోడల్‌లను రూపొందించడంపై YouTubeలో ట్యుటోరియల్ వీడియోలతో ప్రారంభించాను బ్లెండర్. బ్లెండర్ అనేది ఇన్‌స్టాలేషన్ అవసరం లేని 3D మోడలింగ్ (మరియు మరిన్ని) కోసం ఒక అద్భుతమైన ఉచిత సాధనం. మరియు ఇక్కడ నాకు ఒక షాక్ ఎదురుచూసింది... మోడలింగ్, యానిమేషన్, టెక్స్చరింగ్ మీరు పుస్తకాలు వ్రాయగలిగే భారీ ప్రత్యేక అంశాలు అని తేలింది. పాత్రలకు ఇది ప్రత్యేకంగా వర్తిస్తుంది. వేళ్లు, దంతాలు, కళ్ళు మరియు ఇతర శరీర భాగాలను మోడల్ చేయడానికి, మీకు అనాటమీ పరిజ్ఞానం అవసరం. ముఖ కండరాలు ఎలా నిర్మించబడ్డాయి? ప్రజలు ఎలా కదులుతారు? నేను ప్రతి చేయి, కాలు, వేలు, వేళ్ల ఫాలాంగ్స్‌లో ఎముకలను "చొప్పించవలసి వచ్చింది"!

యానిమేషన్ సహజంగా కనిపించేలా చేయడానికి కాలర్‌బోన్‌లు మరియు అదనపు లివర్ బోన్‌లను మోడల్ చేయండి. అటువంటి పాఠాల తర్వాత, యానిమేటెడ్ చిత్రాల సృష్టికర్తలు కేవలం 30 సెకన్ల వీడియోను రూపొందించడానికి ఎంత పని చేస్తారో మీరు తెలుసుకుంటారు. కానీ 3డి సినిమాలు గంటల తరబడి సాగుతాయి! ఆపై మేము సినిమాలను వదిలివేసి ఇలా అంటాము: “అది చెత్త కార్టూన్/సినిమా! వారు ఇంకా బాగా చేయగలిగారు..." మూర్ఖులారా!

మరియు ఈ ప్రాజెక్ట్‌లో ప్రోగ్రామింగ్ గురించి మరొక విషయం. అది ముగిసినప్పుడు, నాకు అత్యంత ఆసక్తికరమైన భాగం గణితశాస్త్రం. మీరు సన్నివేశాన్ని (ప్రాజెక్ట్ వివరణలోని రిపోజిటరీకి లింక్) అమలు చేస్తే, కెమెరా ఒక గోళంలో అమ్మాయి పాత్ర చుట్టూ తిరుగుతున్నట్లు మీరు గమనించవచ్చు. కెమెరా యొక్క అటువంటి భ్రమణాన్ని ప్రోగ్రామ్ చేయడానికి, నేను మొదట వృత్తం (2D), ఆపై గోళం (3D)పై స్థాన బిందువు యొక్క కోఆర్డినేట్‌లను లెక్కించాలి. తమాషా ఏమిటంటే నేను స్కూల్లో గణితాన్ని అసహ్యించుకున్నాను మరియు అది సి-మైనస్‌తో తెలుసు. పాక్షికంగా, బహుశా, ఎందుకంటే పాఠశాలలో వారు ఈ గణితాన్ని జీవితంలో ఎలా ఉపయోగించాలో మీకు వివరించరు. కానీ మీరు మీ లక్ష్యంతో నిమగ్నమైనప్పుడు, మీ కల, మీ మనస్సు క్లియర్ అవుతుంది మరియు తెరుచుకుంటుంది! మరియు మీరు కష్టమైన పనులను ఉత్తేజకరమైన సాహసంగా గ్రహించడం ప్రారంభిస్తారు. ఆపై మీరు ఇలా అనుకుంటారు: "సరే, మీ *ఇష్టమైన* గణిత శాస్త్రజ్ఞుడు ఈ సూత్రాలను ఎక్కడ అన్వయించవచ్చో సాధారణంగా ఎందుకు చెప్పలేకపోయాడు?"

ఒక వృత్తం మరియు గోళంపై ఒక బిందువు యొక్క కోఆర్డినేట్‌లను లెక్కించడానికి సూత్రాల గణన (నా నోట్‌బుక్ నుండి)

గేమ్ 1. సాధారణ పాము

• వేదిక: Windows (Windows 7, 10లో పరీక్షించబడింది)
• భాష: నేను ప్యూర్ సి లో రాశాను అనుకుంటున్నాను
• గేమ్ ఇంజిన్: Windows కన్సోల్
• ప్రేరణ: javidx9
• రిపోజిటరీ: గ్యాలరీలు

సాధారణ పాము గేమ్

3డి దృశ్యం ఆట కాదు. అదనంగా, 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. క్రేజీ ట్యాంకులు

• వేదిక: Windows (Windows 7, 10లో పరీక్షించబడింది)
• భాష: C ++
• గేమ్ ఇంజిన్: Windows కన్సోల్
• ప్రేరణ: ఒక పుస్తకం గేమ్ ప్రోగ్రామింగ్ ద్వారా C++ ప్రారంభం
• రిపోజిటరీ: గ్యాలరీలు

గేమ్ క్రేజీ ట్యాంకులు

కన్సోల్‌కు అక్షరాలను ముద్రించడం అనేది మీరు గేమ్‌గా మార్చగల సులభమైన విషయం. కానీ అప్పుడు ఒక ఇబ్బంది కనిపిస్తుంది: చిహ్నాలు వేర్వేరు ఎత్తులు మరియు వెడల్పులను కలిగి ఉంటాయి (ఎత్తు వెడల్పు కంటే ఎక్కువగా ఉంటుంది). ఈ విధంగా, ప్రతిదీ నిష్పత్తిలో లేకుండా కనిపిస్తుంది మరియు ఎడమ లేదా కుడివైపు కదలడం కంటే క్రిందికి లేదా పైకి కదలడం చాలా వేగంగా కనిపిస్తుంది. ఈ ప్రభావం స్నేక్ (గేమ్ 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_bitmapMemory బిట్‌మ్యాప్‌ను సృష్టిస్తోంది:

// 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;
   }

పైన వివరించిన పద్ధతి ప్రకారం, గేమ్ క్రేజీ ట్యాంక్స్‌లో ఒక చిత్రం (ఫ్రేమ్) ఏర్పడుతుంది మరియు డ్రా() ఫంక్షన్‌లో స్క్రీన్‌పై ప్రదర్శించబడుతుంది. ఇన్‌పుట్() ఫంక్షన్‌లో కీస్ట్రోక్‌లను నమోదు చేసిన తర్వాత మరియు లాజిక్() ఫంక్షన్‌లో వాటి తదుపరి ప్రాసెసింగ్ తర్వాత, కొత్త చిత్రం (ఫ్రేమ్) ఏర్పడుతుంది. నిజమే, ఆట వస్తువులు ఇప్పటికే మైదానంలో వేరే స్థానాన్ని కలిగి ఉండవచ్చు మరియు తదనుగుణంగా, వేరే స్థలంలో డ్రా చేయబడతాయి. యానిమేషన్ (కదలిక) ఇలా జరుగుతుంది.

సిద్ధాంతంలో (నేను ఏదైనా మరచిపోకపోతే), మొదటి గేమ్ (“స్నేక్”) నుండి గేమ్ లూప్‌ను అర్థం చేసుకోవడం మరియు రెండవ గేమ్ (“ట్యాంక్‌లు”) నుండి స్క్రీన్‌పై పిక్సెల్‌లను ప్రదర్శించే సిస్టమ్ (“ట్యాంక్‌లు”) మీరు ఏదైనా రాయాలి. Windows కింద మీ 2D గేమ్‌లు. శబ్దం లేదు! 😉 మిగిలిన భాగాలు కేవలం ఫ్యాన్సీ మాత్రమే.

వాస్తవానికి, "ట్యాంక్స్" ఆట "స్నేక్" కంటే చాలా క్లిష్టంగా ఉంటుంది. నేను ఇప్పటికే C++ లాంగ్వేజ్‌ని ఉపయోగించాను, అంటే తరగతులతో విభిన్న ఆట వస్తువులను వివరించాను. నేను నా స్వంత సేకరణను సృష్టించాను - కోడ్‌ను headers/Box.hలో వీక్షించవచ్చు. మార్గం ద్వారా, సేకరణ ఎక్కువగా మెమరీ లీక్‌ను కలిగి ఉంటుంది. ఉపయోగించిన పాయింటర్లు. జ్ఞాపకశక్తితో పనిచేశారు. ఆ పుస్తకం నాకు చాలా సహాయపడిందని చెప్పాలి గేమ్ ప్రోగ్రామింగ్ ద్వారా C++ ప్రారంభం. C++లో ప్రారంభకులకు ఇది గొప్ప ప్రారంభం. ఇది చిన్నది, ఆసక్తికరంగా మరియు చక్కగా నిర్వహించబడింది.

ఈ గేమ్‌ను అభివృద్ధి చేయడానికి దాదాపు ఆరు నెలలు పట్టింది. నేను ప్రధానంగా పనిలో భోజనం మరియు స్నాక్స్ సమయంలో వ్రాసాను. ఆఫీస్ కిచెన్‌లో కూర్చుని ఆహారాన్ని తొక్కేసి కోడ్ రాసుకున్నాడు. లేదా ఇంట్లో విందులో. కాబట్టి నేను ఈ "వంటగది యుద్ధాలతో" ముగించాను. ఎప్పటిలాగే, నేను నోట్‌బుక్‌ను చురుకుగా ఉపయోగించాను మరియు సంభావిత విషయాలన్నీ దానిలో పుట్టాయి.

ఆచరణాత్మక భాగాన్ని పూర్తి చేయడానికి, నేను నా నోట్‌బుక్ యొక్క కొన్ని స్కాన్‌లను తీసుకుంటాను. నేను వ్రాసిన, గీసిన, లెక్కించిన, రూపకల్పన చేసిన వాటిని సరిగ్గా చూపించడానికి...

ట్యాంకుల చిత్రాల రూపకల్పన. మరియు స్క్రీన్‌పై ప్రతి ట్యాంక్ ఎన్ని పిక్సెల్‌లను ఆక్రమించాలో నిర్ణయించడం

దాని అక్షం చుట్టూ ట్యాంక్ యొక్క భ్రమణ కోసం అల్గోరిథం మరియు సూత్రాల గణన

నా సేకరణ యొక్క స్కీమ్ (మెమొరీ లీక్ ఉన్నది, చాలా మటుకు). లింక్ చేయబడిన జాబితా రకం ప్రకారం సేకరణ సృష్టించబడింది

మరియు ఇవి గేమ్‌కు కృత్రిమ మేధస్సును జోడించడానికి వ్యర్థమైన ప్రయత్నాలు

సిద్ధాంతం

“వెయ్యి మైళ్ల ప్రయాణం కూడా మొదటి అడుగుతోనే ప్రారంభమవుతుంది” (ప్రాచీన చైనీస్ జ్ఞానం)

అభ్యాసం నుండి సిద్ధాంతానికి వెళ్దాం! మీ అభిరుచి కోసం సమయాన్ని ఎలా కనుగొనాలి?

1. మీకు నిజంగా ఏమి కావాలో నిర్ణయించండి (అయ్యో, ఇది కష్టతరమైన భాగం).
2. ప్రాధాన్యతలను సెట్ చేయండి.
3. అధిక ప్రాధాన్యతల కొరకు "అదనపు" ప్రతిదీ త్యాగం చేయండి.
4. ప్రతి రోజు లక్ష్యాల వైపు వెళ్లండి.
5. రెండు లేదా మూడు గంటల ఖాళీ సమయాన్ని హాబీలో గడపాలని అనుకోకండి.

ఒక వైపు, మీరు ఏమి కోరుకుంటున్నారో నిర్ణయించుకోవాలి మరియు ప్రాధాన్యత ఇవ్వాలి. మరోవైపు, ఈ ప్రాధాన్యతలకు అనుకూలంగా కొన్ని కార్యకలాపాలు/ప్రాజెక్టులను వదిలివేయడం సాధ్యమవుతుంది. మరో మాటలో చెప్పాలంటే, మీరు "అదనపు" ప్రతిదీ త్యాగం చేయవలసి ఉంటుంది. జీవితంలో గరిష్టంగా మూడు ప్రధాన కార్యకలాపాలు ఉండాలని నేను ఎక్కడో విన్నాను. అప్పుడు మీరు వాటిని అత్యధిక నాణ్యతతో చేయగలుగుతారు. మరియు అదనపు ప్రాజెక్ట్‌లు/దిశలు ఓవర్‌లోడ్ చేయడం ప్రారంభిస్తాయి. కానీ ఇదంతా బహుశా ఆత్మాశ్రయమైనది మరియు వ్యక్తిగతమైనది.

ఒక నిర్దిష్ట గోల్డెన్ రూల్ ఉంది: ఎప్పుడూ 0% రోజు ఉండకూడదు! నేను ఇండీ డెవలపర్ ద్వారా ఒక కథనంలో దాని గురించి తెలుసుకున్నాను. మీరు ఒక ప్రాజెక్ట్‌లో పని చేస్తుంటే, ప్రతిరోజూ దాని గురించి ఏదైనా చేయండి. మరియు మీరు ఎంత చేసినా పట్టింపు లేదు. ఒక పదం లేదా ఒక లైన్ కోడ్ రాయండి, ఒక ట్యుటోరియల్ వీడియోని చూడండి లేదా ఒక గోరును బోర్డులో కొట్టండి - ఏదైనా చేయండి. కష్టతరమైన విషయం ఏమిటంటే ప్రారంభించడం. మీరు ప్రారంభించిన తర్వాత, మీరు కోరుకున్న దానికంటే కొంచెం ఎక్కువ చేయడం బహుశా ముగించవచ్చు. ఈ విధంగా మీరు నిరంతరం మీ లక్ష్యం వైపు వెళతారు మరియు నన్ను నమ్మండి, చాలా త్వరగా. అన్నింటికంటే, అన్ని విషయాలకు ప్రధాన అడ్డంకి వాయిదా వేయడం.

మరియు మీరు 5, 10, 15 నిమిషాల ఉచిత “సాడస్ట్” ని తక్కువ అంచనా వేయకూడదని మరియు విస్మరించకూడదని గుర్తుంచుకోవడం ముఖ్యం, కొన్ని పెద్ద “లాగ్‌ల” కోసం గంట లేదా రెండు గంటలు వేచి ఉండండి. మీరు లైన్‌లో నిలబడి ఉన్నారా? మీ ప్రాజెక్ట్ కోసం ఏదైనా ఆలోచించండి. ఎస్కలేటర్ తీసుకుంటున్నారా? నోట్‌ప్యాడ్‌లో ఏదైనా రాయండి. మీరు బస్సులో ప్రయాణిస్తున్నారా? చాలా బాగుంది, కొన్ని కథనాలను చదవండి. ప్రతి అవకాశాన్ని సద్వినియోగం చేసుకోండి. YouTubeలో పిల్లులు మరియు కుక్కలను చూడటం మానేయండి! మీ మెదడును కలుషితం చేయవద్దు!

మరియు చివరి విషయం. ఈ కథనాన్ని చదివిన తర్వాత, గేమ్ ఇంజిన్‌లను ఉపయోగించకుండా గేమ్‌లను సృష్టించే ఆలోచన మీకు నచ్చినట్లయితే, కేసీ మురాటోరి పేరును గుర్తుంచుకోండి. ఈ వ్యక్తికి ఉంది వెబ్సైట్. “వాచ్ -> మునుపటి ఎపిసోడ్‌లు” విభాగంలో మీరు మొదటి నుండి ప్రొఫెషనల్ గేమ్‌ను రూపొందించడంలో అద్భుతమైన ఉచిత వీడియో ట్యుటోరియల్‌లను కనుగొంటారు. విండోస్ పాఠాల కోసం సి నుండి ఐదు ఉపోద్ఘాతంలో మీరు బహుశా ఐదేళ్ల విశ్వవిద్యాలయ అధ్యయనం కంటే ఎక్కువ నేర్చుకుంటారు (వీడియో క్రింద ఉన్న వ్యాఖ్యలలో ఎవరైనా దీని గురించి వ్రాసారు).

మీ స్వంత గేమ్ ఇంజిన్‌ను అభివృద్ధి చేయడం ద్వారా, ఇప్పటికే ఉన్న ఏవైనా ఇంజిన్‌ల గురించి మీకు మంచి అవగాహన ఉంటుందని కూడా కేసీ వివరించాడు. ప్రతి ఒక్కరూ ఆటోమేట్ చేయడానికి ప్రయత్నిస్తున్న ఫ్రేమ్‌వర్క్‌ల ప్రపంచంలో, మీరు ఉపయోగించడం కంటే సృష్టించడం నేర్చుకుంటారు. మీరు కంప్యూటర్ల స్వభావాన్ని అర్థం చేసుకున్నారు. మరియు మీరు మరింత తెలివైన మరియు పరిణతి చెందిన ప్రోగ్రామర్ అవుతారు - ప్రో.

మీరు ఎంచుకున్న మార్గంలో అదృష్టం! మరియు ప్రపంచాన్ని మరింత ప్రొఫెషనల్‌గా చేద్దాం.

రచయిత: గ్రాంకిన్ ఆండ్రీ, DevOps

మూలం: www.habr.com