DevOps C++ at "kitchen wars", o Paano ako nagsimulang magsulat ng mga laro habang kumakain

"Alam kong wala akong alam" Socrates

Para kanino: para sa mga taong IT na walang pakialam sa lahat ng developer at gustong maglaro ng kanilang mga laro!

Tungkol Saan: tungkol sa kung paano magsimulang magsulat ng mga laro sa C/C++, kung bigla mo itong kailanganin!

Bakit mo dapat basahin ito: Ang pagbuo ng application ay hindi ang aking lugar ng kadalubhasaan, ngunit sinusubukan kong mag-code bawat linggo. Dahil mahilig ako sa mga laro!

Kamusta? Ang pangalan ko ay Andrey Grankin, DevOps ako sa Luxoft. Ang pagbuo ng application ay hindi ang aking espesyalidad, ngunit sinusubukan kong mag-code bawat linggo. Dahil mahilig ako sa mga laro!

Ang industriya ng paglalaro ng kompyuter ay napakalaki, sinasabing mas malaki pa kaysa sa industriya ng pelikula ngayon. Ang mga laro ay isinulat mula pa noong madaling araw ng mga kompyuter, gamit, ayon sa mga modernong pamantayan, kumplikado at pangunahing mga pamamaraan ng pag-unlad. Sa paglipas ng panahon, nagsimulang lumitaw ang mga game engine na may naka-program na graphics, physics, at tunog. Pinapayagan ka nitong tumuon sa pagbuo ng laro mismo at huwag mag-alala tungkol sa pundasyon nito. Ngunit kasama nila, kasama ang mga makina, ang mga developer ay "nabubulag" at nagpapasama. Ang paggawa ng mga laro mismo ay inilalagay sa conveyor belt. At ang dami ng mga produkto ay nagsisimulang mangibabaw sa kalidad nito.

Kasabay nito, kapag naglalaro ng mga laro ng ibang tao, palagi tayong nalilimitahan ng mga lokasyon, plot, karakter, at mekanika ng laro na naisip ng ibang tao. Kaya napagtanto ko na...

... dumating na ang oras upang lumikha ng sarili kong mga mundo, na napapailalim lamang sa akin. Mga mundo kung saan Ako ang Ama, ang Anak, at ang Banal na Espiritu!

At taos-puso akong naniniwala na sa pamamagitan ng pagsulat ng iyong sariling game engine at paglalaro dito, magagawa mong tanggalin ang iyong sapatos, punasan ang mga bintana at i-upgrade ang iyong cabin, maging isang mas may karanasan at kumpletong programmer.

Sa artikulong ito susubukan kong sabihin sa iyo kung paano ako nagsimulang magsulat ng maliliit na laro sa C/C++, kung ano ang proseso ng pag-unlad, at kung saan ako nakakahanap ng oras para sa isang libangan sa isang abalang kapaligiran. Ito ay subjective at inilalarawan ang proseso ng isang indibidwal na simula. Materyal tungkol sa kamangmangan at pananampalataya, tungkol sa aking personal na larawan ng mundo sa kasalukuyan. Sa madaling salita, "Ang administrasyon ay hindi responsable para sa iyong mga personal na utak!"

Pagsasanay

"Ang kaalaman na walang kasanayan ay walang silbi, ang pagsasanay na walang kaalaman ay mapanganib" Confucius

Ang aking notebook ay ang aking buhay!

Kaya, sa pagsasanay, masasabi kong para sa akin ang lahat ay nagsisimula sa isang notepad. Hindi ko lang isinulat ang aking mga pang-araw-araw na gawain doon, ako rin ay gumuhit, nagprograma, nagdidisenyo ng mga flowchart at nagso-solve ng mga problema, kasama na ang mga mathematical. Laging gumamit ng notepad at magsulat lamang sa lapis. Ito ay malinis, maginhawa at maaasahan, IMHO.

Ang aking (napuno na ng) notebook. Ito ang itsura niya. Naglalaman ito ng mga pang-araw-araw na gawain, ideya, guhit, diagram, solusyon, itim na bookkeeping, code at iba pa

Sa yugtong ito, nagawa kong makumpleto ang tatlong proyekto (ito ay nasa aking pag-unawa sa "pagkakumpleto", dahil ang anumang produkto ay maaaring mabuo nang walang katapusan).

• Proyekto 0: Ito ay isang 3D Architect Demo scene na nakasulat sa C# gamit ang Unity game engine. Para sa macOS at Windows platform.
• Laro 1: console game na Simple Snake (kilala ng lahat bilang "Snake") para sa Windows. Nakasulat sa C.
• Laro 2: console game na Crazy Tanks (kilala sa lahat bilang "Tanks"), nakasulat sa C++ (gamit ang mga klase) at para din sa Windows.

Proyekto 0. Arkitekto Demo

• Platform: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• Wika: C#
• Game engine: Pagkakaisa
• Inspirasyon: Darrin Lile
• Imbakan: GitHub

Demo ng 3D Scene Architect

Ang unang proyekto ay ipinatupad hindi sa C/C++, ngunit sa C# gamit ang Unity game engine. Ang makina na ito ay hindi kasing hinihingi sa hardware Imitasyon Engine, at tila mas madaling i-install at gamitin. Hindi ko isinasaalang-alang ang iba pang mga makina.

Ang layunin ko sa Unity ay hindi bumuo ng laro. Nais kong lumikha ng isang 3D na eksena na may ilang karakter. Siya, o sa halip Siya (ginawa ko ang babaeng minahal ko =) ay kailangang kumilos at makipag-ugnayan sa mundo sa paligid niya. Mahalaga lamang na maunawaan kung ano ang Unity, kung ano ang proseso ng pag-unlad at kung gaano karaming pagsisikap ang kinakailangan upang lumikha ng isang bagay. Ito ay kung paano ipinanganak ang proyekto ng Architect Demo (halos naimbento ang pangalan nang wala sa oras). Ang programming, pagmomodelo, animation, pag-texture ay inabot ako ng dalawang buwan ng pang-araw-araw na trabaho.

Nagsimula ako sa mga tutorial na video sa YouTube sa paggawa ng mga 3D na modelo sa Blender. Ang Blender ay isang mahusay na libreng tool para sa 3D modeling (at higit pa) na hindi nangangailangan ng pag-install. At narito ang isang pagkabigla na naghihintay sa akin... Lumalabas na ang pagmomodelo, animation, pag-texture ay napakalaking magkahiwalay na paksa kung saan maaari kang sumulat ng mga libro. Ito ay totoo lalo na para sa mga character. Upang magmodelo ng mga daliri, ngipin, mata at iba pang bahagi ng katawan, kakailanganin mo ng kaalaman sa anatomy. Paano nakaayos ang mga kalamnan sa mukha? Paano gumagalaw ang mga tao? Kinailangan kong "ipasok" ang mga buto sa bawat braso, binti, daliri, phalanges ng mga daliri!

I-modelo ang mga collarbone at karagdagang lever bone para gawing natural ang animation. Pagkatapos ng gayong mga aralin, napagtanto mo kung gaano karaming trabaho ang ginagawa ng mga tagalikha ng mga animated na pelikula para lamang gumawa ng 30 segundo ng video. Ngunit ang mga 3D na pelikula ay tumatagal ng ilang oras! At pagkatapos ay umalis kami sa mga sinehan at sabihin ang isang bagay tulad ng: "That's a crap cartoon/movie! Mas maganda sana ang ginawa nila..." Mga tanga!

At isa pang bagay tungkol sa programming sa proyektong ito. Tulad ng nangyari, ang pinaka-kagiliw-giliw na bahagi para sa akin ay ang matematika. Kung patakbuhin mo ang eksena (link sa repository sa paglalarawan ng proyekto), mapapansin mong umiikot ang camera sa paligid ng karakter ng babae sa isang globo. Upang i-program ang gayong pag-ikot ng camera, kailangan ko munang kalkulahin ang mga coordinate ng punto ng posisyon sa bilog (2D), at pagkatapos ay sa globo (3D). Ang nakakatawang bagay ay kinasusuklaman ko ang matematika sa paaralan at alam ko ito na may C-minus. Sa isang bahagi, marahil, dahil sa paaralan ay hindi nila ipinapaliwanag sa iyo kung paano inilalapat ang matematika na ito sa buhay. Ngunit kapag nahuhumaling ka sa iyong layunin, ang iyong pangarap, ang iyong isip ay lumilinaw at nagbubukas! At sinimulan mong malasahan ang mahihirap na gawain bilang isang kapana-panabik na pakikipagsapalaran. At pagkatapos ay iisipin mo: "Buweno, bakit hindi normal na sabihin sa iyo ng iyong *paboritong* mathematician kung saan maaaring ilapat ang mga formula na ito?"

Pagkalkula ng mga formula para sa pagkalkula ng mga coordinate ng isang punto sa isang bilog at sa isang globo (mula sa aking notebook)

Laro 1. Simpleng Ahas

• Platform: Windows (nasubok sa Windows 7, 10)
• Wika: Sa tingin ko sinulat ko ito sa purong C
• Game engine: Windows console
• Inspirasyon: javidx9
• Imbakan: GitHub

Simpleng laro ng ahas

Ang isang 3D na eksena ay hindi isang laro. Bilang karagdagan, ang pagmomodelo at pag-animate ng mga 3D na bagay (lalo na ang mga character) ay nakakaubos ng oras at mahirap. Matapos makipaglaro sa Unity, napagtanto ko na kailangan kong magpatuloy, o sa halip magsimula, mula sa mga pangunahing kaalaman. Isang bagay na simple at mabilis, ngunit sa parehong oras global, upang maunawaan ang napaka istraktura ng mga laro.

Ano ang simple at mabilis? Tama iyon, console at 2D. Mas tiyak, maging ang console at mga simbolo. Muli akong naghanap ng inspirasyon sa Internet (sa pangkalahatan, sa tingin ko ang Internet ang pinaka-rebolusyonaryo at mapanganib na imbensyon ng ika-XNUMX siglo). Naghukay ako ng video ng isang programmer na gumawa ng console ng Tetris. At sa pagkakahawig ng kanyang laro ay nagpasya akong gumawa ng isang "ahas". Mula sa video natutunan ko ang tungkol sa dalawang pangunahing bagay - ang loop ng laro (na may tatlong pangunahing pag-andar/bahagi) at output sa buffer.

Maaaring ganito ang hitsura ng loop ng laro:

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

Ang code ay nagpapakita ng buong main() function nang sabay-sabay. At magsisimula ang ikot ng laro pagkatapos ng naaangkop na komento. May tatlong pangunahing function sa loop: Input(), Logic(), Draw(). Una, input ng data Input (pangunahin ang kontrol ng mga keystroke), pagkatapos ay iproseso ang ipinasok na data Logic, pagkatapos ay output sa screen - Gumuhit. At iba pa sa bawat frame. Ito ay kung paano nilikha ang animation. Parang sa cartoons. Karaniwan, ang pagproseso ng inilagay na data ay tumatagal ng pinakamaraming oras at, sa pagkakaalam ko, tinutukoy ang frame rate ng laro. Ngunit dito ang Logic() function ay napakabilis na gumagana. Samakatuwid, kailangan mong kontrolin ang frame rate gamit ang Sleep() function na may gameSpeed ​​​​parameter, na tumutukoy sa bilis na ito.

Ikot ng laro. Pagprograma ng "ahas" sa isang notepad

Kung gumagawa ka ng isang character-based na console game, hindi ka makakapag-output ng data sa screen gamit ang regular na 'cout' stream output - napakabagal nito. Samakatuwid, ang output ay dapat ipadala sa buffer ng screen. Ito ay mas mabilis at ang laro ay tatakbo nang walang glitches. Sa totoo lang, hindi ko masyadong naiintindihan kung ano ang screen buffer at kung paano ito gumagana. Ngunit magbibigay ako ng isang halimbawa ng code dito, at marahil ay maaaring linawin ng isang tao ang sitwasyon sa mga komento.

Pagkuha ng screen buffer (kaya sabihin):

// create screen buffer for drawings
   HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
 							   NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
   DWORD dwBytesWritten = 0;
   SetConsoleActiveScreenBuffer(hConsole);

Direktang pagpapakita ng isang partikular na string scoreLine (score display line):

// draw the score
   WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);

Sa teorya, walang kumplikado sa larong ito; Sa tingin ko ito ay isang magandang halimbawa ng entry-level. Ang code ay nakasulat sa isang file at na-format sa ilang mga function. Walang klase, walang mana. Makikita mo ang lahat sa source code ng laro sa pamamagitan ng pagpunta sa repository sa GitHub.

Laro 2. Crazy Tanks

• Platform: Windows (nasubok sa Windows 7, 10)
• Wika: C + +
• Game engine: Windows console
• Inspirasyon: aklat Nagsisimula sa C++ Sa pamamagitan ng Game Programming
• Imbakan: GitHub

Game Crazy Tank

Ang pagpi-print ng mga character sa console ay marahil ang pinakasimpleng bagay na maaari mong gawing laro. Ngunit pagkatapos ay lumitaw ang isang problema: ang mga simbolo ay may iba't ibang taas at lapad (ang taas ay mas malaki kaysa sa lapad). Sa ganitong paraan, magmumukhang wala sa proporsyon ang lahat, at ang paglipat pababa o pataas ay lalabas nang mas mabilis kaysa sa paglipat ng kaliwa o kanan. Ang epektong ito ay kapansin-pansin sa Snake (Laro 1). Ang "Tanks" (Game 2) ay walang ganitong disbentaha, dahil ang output doon ay nakaayos sa pamamagitan ng pagpipinta ng mga pixel ng screen na may iba't ibang kulay. Masasabi mong sumulat ako ng isang renderer. Totoo, ito ay medyo mas kumplikado, kahit na mas kawili-wili.

Para sa larong ito, ito ay sapat na upang ilarawan ang aking sistema para sa pagpapakita ng mga pixel sa screen. Itinuturing kong ito ang pangunahing bahagi ng laro. At maaari mong gawin ang lahat ng iba pa sa iyong sarili.

Kaya, ang nakikita mo sa screen ay isang hanay lamang ng mga gumagalaw na multi-colored na parihaba.

Set ng mga parihaba

Ang bawat parihaba ay kinakatawan ng isang matrix na puno ng mga numero. Sa pamamagitan ng paraan, maaari kong i-highlight ang isang kawili-wiling nuance - lahat ng mga matrice sa laro ay naka-program bilang isang one-dimensional na array. Hindi two-dimensional, ngunit one-dimensional! Ang mga one-dimensional na array ay mas madali at mas mabilis na gamitin.

Halimbawa ng isang game tank matrix

Representasyon ng game tank matrix bilang one-dimensional array

Isang mas visual na halimbawa ng kumakatawan sa isang matrix bilang isang one-dimensional array

Ngunit ang pag-access sa mga elemento ng array ay nangyayari sa isang double loop, na parang hindi ito isang one-dimensional array, ngunit isang two-dimensional na isa. Ginagawa ito dahil nagtatrabaho pa rin kami sa mga matrice.

Ang pagtawid sa isang one-dimensional na array sa isang double loop. Y - row identifier, X - column identifier

Pakitandaan: sa halip na ang karaniwang matrix identifier na i, j, ginagamit ko ang mga identifier na x at y. Sa ganitong paraan, tila sa akin, ito ay mas nakalulugod sa mata at mas naiintindihan ng utak. Bilang karagdagan, ginagawang posible ng naturang notasyon na maginhawang i-project ang mga matrice na ginamit sa mga coordinate axes ng isang two-dimensional na imahe.

Ngayon tungkol sa mga pixel, kulay at output ng screen. Ang StretchDIBits function ay ginagamit para sa output (Header: windows.h; Library: gdi32.lib). Ang function na ito, bukod sa iba pang mga bagay, ay tumatanggap ng mga sumusunod: ang device kung saan ipinapakita ang imahe (sa aking kaso, ito ay ang Windows console), ang mga start coordinates ng display ng imahe, ang lapad/taas nito, at ang imahe mismo sa anyo ng isang bitmap, na kinakatawan ng isang hanay ng mga byte. Bitmap bilang isang byte array!

Gumaganap ang StretchDIBits() function:

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

Ang memorya ay inilalaan nang maaga para sa bitmap na ito gamit ang VirtualAlloc() function. Iyon ay, ang kinakailangang bilang ng mga byte ay nakalaan upang mag-imbak ng impormasyon tungkol sa lahat ng mga pixel, na pagkatapos ay ipapakita sa screen.

Paglikha ng 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);

Sa halos pagsasalita, ang isang bitmap ay binubuo ng isang hanay ng mga pixel. Ang bawat apat na byte sa array ay isang RGB pixel. Isang byte sa bawat pulang kulay na halaga, isang byte sa bawat berdeng halaga ng kulay (G), at isang byte sa bawat asul na halaga ng kulay (B). Plus may isang byte na natitira para sa indentation. Ang tatlong kulay na ito - Pula/Berde/Asul (RGB) - ay pinaghalo sa isa't isa sa iba't ibang sukat upang malikha ang resultang kulay ng pixel.

Ngayon, muli, ang bawat parihaba, o bagay ng laro, ay kinakatawan ng isang numeric matrix. Ang lahat ng mga bagay na ito ng laro ay inilalagay sa isang koleksyon. At pagkatapos ay inilalagay sila sa larangan ng paglalaro, na bumubuo ng isang malaking numerical matrix. Iniugnay ko ang bawat numero sa matrix sa isang tiyak na kulay. Halimbawa, ang numero 8 ay tumutugma sa asul, ang numero 9 sa dilaw, ang numero 10 sa dark grey, at iba pa. Kaya, maaari nating sabihin na mayroon tayong matrix ng playing field, kung saan ang bawat numero ay isang kulay.

Kaya, mayroon kaming numeric matrix ng buong playing field sa isang gilid at isang bitmap para sa pagpapakita ng imahe sa kabilang panig. Sa ngayon, ang bitmap ay "walang laman" - hindi pa ito naglalaman ng impormasyon tungkol sa mga pixel ng nais na kulay. Nangangahulugan ito na ang huling hakbang ay upang i-populate ang bitmap ng impormasyon tungkol sa bawat pixel batay sa numeric matrix ng playing field. Ang isang malinaw na halimbawa ng naturang pagbabago ay nasa larawan sa ibaba.

Isang halimbawa ng pagpuno ng bitmap (Pixel matrix) ng impormasyon batay sa Digital matrix ng playing field (hindi tumutugma ang mga indeks ng kulay sa mga indeks sa laro)

Magpapakita din ako ng isang piraso ng totoong code mula sa laro. Ang variable na colorIndex sa bawat pag-ulit ng loop ay itinalaga ng isang halaga (index ng kulay) mula sa numeric matrix ng playing field (mainDigitalMatrix). Ang variable ng kulay ay itatakda sa mismong kulay batay sa index. Ang resultang kulay ay nahahati sa ratio ng pula, berde at asul (RGB). At kasama ng pixelPadding, ang impormasyong ito ay nakasulat sa pixel nang paulit-ulit, na bumubuo ng isang kulay na imahe sa bitmap.

Gumagamit ang code ng mga pointer at bitwise na operasyon, na maaaring mahirap maunawaan. Kaya't ipinapayo ko sa iyo na basahin sa isang lugar nang hiwalay kung paano gumagana ang gayong mga istruktura.

Ang pagpuno sa bitmap ng impormasyon batay sa numeric matrix ng playing field:

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

Ayon sa pamamaraang inilarawan sa itaas, sa larong Crazy Tanks isang larawan (frame) ang nabuo at ipinapakita sa screen sa Draw() function. Pagkatapos magrehistro ng mga keystroke sa Input() function at ang kanilang kasunod na pagproseso sa Logic() function, isang bagong larawan (frame) ang nabuo. Totoo, ang mga bagay sa laro ay maaaring mayroon nang ibang posisyon sa larangan ng paglalaro at, nang naaayon, ay iginuhit sa ibang lugar. Ganito nangyayari ang animation (movement).

Sa teorya (kung wala akong nakalimutan), ang pag-unawa sa loop ng laro mula sa unang laro ("Ahas") at ang sistema para sa pagpapakita ng mga pixel sa screen mula sa pangalawang laro ("Mga Tank") ay ang kailangan mo lang isulat ang anumang ng iyong mga 2D na laro sa ilalim ng Windows. Walang tunog! 😉 Ang natitira sa mga bahagi ay isang paglipad ng fancy.

Siyempre, ang larong "Tanks" ay mas kumplikado kaysa sa "Ahas". Nagamit ko na ang wikang C++, ibig sabihin, inilarawan ko ang iba't ibang mga bagay sa laro na may mga klase. Gumawa ako ng sarili kong koleksyon - maaaring matingnan ang code sa mga header/Box.h. Sa pamamagitan ng paraan, ang koleksyon ay malamang na may memory leak. Ginamit na mga payo. Nagtrabaho nang may memorya. Dapat kong sabihin na ang libro ay nakatulong ng malaki sa akin Nagsisimula sa C++ Sa pamamagitan ng Game Programming. Ito ay isang magandang simula para sa mga nagsisimula sa C++. Ito ay maliit, kawili-wili at maayos na nakaayos.

Tumagal ng humigit-kumulang anim na buwan upang mabuo ang larong ito. Sumulat ako pangunahin sa tanghalian at meryenda sa trabaho. Umupo siya sa kusina ng opisina, tinapakan ang pagkain at nagsulat ng code. O sa hapunan sa bahay. Kaya natapos ko itong "mga digmaan sa kusina." Gaya ng nakasanayan, aktibong gumamit ako ng isang kuwaderno, at lahat ng mga konseptong bagay ay ipinanganak dito.

Upang makumpleto ang praktikal na bahagi, kukuha ako ng ilang pag-scan ng aking notebook. Upang ipakita kung ano ang eksaktong isinulat ko, iginuhit, binilang, idinisenyo...

Pagdidisenyo ng mga larawan ng mga tangke. At pagtukoy kung gaano karaming mga pixel ang dapat sakupin ng bawat tangke sa screen

Pagkalkula ng algorithm at mga formula para sa pag-ikot ng tangke sa paligid ng axis nito

Scheme ng aking koleksyon (ang isa kung saan mayroong memory leak, malamang). Ang koleksyon ay nilikha ayon sa uri ng Linked List

At ito ay walang saysay na mga pagtatangka upang ilakip ang artificial intelligence sa laro

Теория

"Kahit isang paglalakbay ng isang libong milya ay nagsisimula sa unang hakbang" (Karunungan ng Sinaunang Tsino)

Lumipat tayo mula sa pagsasanay patungo sa teorya! Paano makahanap ng oras para sa iyong libangan?

1. Tukuyin kung ano talaga ang gusto mo (sayang, ito ang pinakamahirap na bahagi).
2. Magtakda ng mga priyoridad.
3. Isakripisyo ang lahat ng "dagdag" para sa mas mataas na priyoridad.
4. Lumipat patungo sa mga layunin araw-araw.
5. Huwag asahan ang dalawa o tatlong oras ng libreng oras na gugugol sa isang libangan.

Sa isang banda, kailangan mong matukoy kung ano ang gusto mo at unahin. Sa kabilang banda, posibleng iwanan ang ilang aktibidad/proyekto na pabor sa mga priyoridad na ito. Sa madaling salita, kailangan mong isakripisyo ang lahat ng "dagdag". Narinig ko sa isang lugar na dapat mayroong maximum na tatlong pangunahing aktibidad sa buhay. Pagkatapos ay magagawa mo ang mga ito sa pinakamataas na kalidad. At magsisimulang mag-overload ang mga karagdagang proyekto/direksyon. Ngunit ang lahat ng ito ay malamang na subjective at indibidwal.

Mayroong isang tiyak na ginintuang tuntunin: huwag magkaroon ng 0% na araw! Nalaman ko ang tungkol dito sa isang artikulo ng isang indie developer. Kung gumagawa ka ng isang proyekto, gumawa ng isang bagay tungkol dito araw-araw. At hindi mahalaga kung gaano mo ginagawa. Sumulat ng isang salita o isang linya ng code, manood ng isang tutorial na video o martilyo ng isang kuko sa isang board - gumawa lang ng isang bagay. Ang pinakamahirap na bagay ay magsimula. Kapag nagsimula ka, malamang na gagawa ka ng higit pa sa gusto mo. Sa paraang ito ay patuloy kang kikilos patungo sa iyong layunin at, maniwala ka sa akin, nang napakabilis. Pagkatapos ng lahat, ang pangunahing hadlang sa lahat ng bagay ay pagpapaliban.

At mahalagang tandaan na hindi mo dapat maliitin at huwag pansinin ang libreng "sawdust" ng oras na 5, 10, 15 minuto, maghintay para sa ilang malalaking "log" na tumatagal ng isang oras o dalawa. Nakapila ka ba? Mag-isip tungkol sa isang bagay para sa iyong proyekto. Sumakay sa escalator? Sumulat ng isang bagay sa isang notepad. Naglalakbay ka ba sa bus? Mahusay, magbasa ng ilang artikulo. Samantalahin ang bawat pagkakataon. Itigil ang panonood ng mga pusa at aso sa YouTube! Wag mong dungisan ang utak mo!

At isang huling bagay. Kung, pagkatapos basahin ang artikulong ito, nagustuhan mo ang ideya ng paglikha ng mga laro nang hindi gumagamit ng mga engine ng laro, pagkatapos ay tandaan ang pangalang Casey Muratori. Ang lalaking ito ay mayroon website. Sa seksyong "panoorin -> MGA NAkaraang EPISOD" makikita mo ang magagandang libreng video tutorial sa paglikha ng isang propesyonal na laro mula sa simula. Sa limang Intro to C para sa Windows na mga aralin ay malamang na matututo ka ng higit sa limang taon ng pag-aaral sa unibersidad (may sumulat tungkol dito sa mga komento sa ilalim ng video).

Ipinaliwanag din ni Casey na sa pamamagitan ng pagbuo ng iyong sariling game engine, magkakaroon ka ng mas mahusay na pag-unawa sa anumang mga umiiral na engine. Sa mundo ng mga framework kung saan sinusubukan ng lahat na mag-automate, natututo kang lumikha sa halip na gumamit. Naiintindihan mo ang mismong kalikasan ng mga computer. At ikaw ay magiging isang mas matalino at mature na programmer - isang pro.

Good luck sa iyong napiling landas! At gawin nating mas propesyonal ang mundo.

May-akda: Kuya Andrey, DevOps

Pinagmulan: www.habr.com