DevOps C++ ו-"Kitchen Wars", או איך התחלתי לכתוב משחקים תוך כדי אכילה

"אני יודע שאני לא יודע כלום" סוקרטס

למי: לאנשי IT שיורקים על כל המפתחים ורוצים לשחק במשחקים שלהם!

לגבי מה: איך להתחיל לכתוב משחקים ב-C/C++ אם אתה צריך את זה!

למה כדאי לקרוא את זה: פיתוח אפליקציות זה לא המומחיות שלי בעבודה, אבל אני משתדל לקוד כל שבוע. כי אני אוהב משחקים!

שלום שמי הוא אנדריי גרנקין, אני DevOps ב- Luxoft. פיתוח אפליקציות הוא לא מומחיות העבודה שלי, אבל אני משתדל לקוד כל שבוע. כי אני אוהב משחקים!

תעשיית משחקי המחשב היא ענקית, אפילו יותר שמועות היום מאשר תעשיית הקולנוע. משחקים נכתבו מאז תחילת הפיתוח של המחשבים, תוך שימוש, בסטנדרטים מודרניים, בשיטות פיתוח מורכבות ובסיסיות. עם הזמן, מנועי משחק החלו להופיע עם גרפיקה, פיזיקה וסאונד מתוכנתים כבר. הם מאפשרים לך להתמקד בפיתוח המשחק עצמו ולא להתעסק בבסיס שלו. אבל יחד איתם, עם המנועים, המפתחים "מתעוורים" ומתכלים. עצם ייצור המשחקים מועלה על המסוע. וכמות הייצור מתחילה לגבור על איכותו.

יחד עם זאת, כאשר משחקים במשחקים של אחרים, אנו מוגבלים כל הזמן על ידי מיקומים, עלילה, דמויות, מכניקת משחק שאנשים אחרים הגיעו אליהם. אז הבנתי ש...

... הגיע הזמן ליצור את העולמות שלך, כפופים רק לי. עולמות שבהם אני האב, והבן, ורוח הקודש!

ואני מאמין באמת ובתמים שעל ידי כתיבת מנוע משחק משלך ומשחק עליו, תוכל לפקוח את העיניים, לנגב את החלונות ולשאוב את התא שלך, ולהפוך למתכנת מנוסה ואינטגרלי יותר.

במאמר זה אנסה לספר לכם איך התחלתי לכתוב משחקים קטנים ב-C/C++, מהו תהליך הפיתוח והיכן אני מוצא זמן לתחביב בסביבה עמוסה. זה סובייקטיבי ומתאר את התהליך של התחלה אישית. חומר על בורות ואמונה, על תמונת העולם האישית שלי כרגע. במילים אחרות, "הממשל אינו אחראי על המוח האישי שלך!".

עיסוק

"ידע ללא תרגול הוא חסר תועלת, תרגול ללא ידע הוא מסוכן." קונפוציוס

המחברת שלי היא החיים שלי!

אז, בפועל, אני יכול לומר שהכל בשבילי מתחיל במחברת. אני רושם שם לא רק את המשימות היומיומיות שלי, אלא גם מצייר, מתכנת, מעצב תרשימי זרימה ופותר בעיות, כולל מתמטיות. השתמש תמיד בפנקס וכתוב רק בעיפרון. זה נקי, נוח ואמין, IMHO.

המחברת שלי (שמלאה כבר). כך זה נראה. הוא מכיל משימות יומיומיות, רעיונות, שרטוטים, דיאגרמות, פתרונות, הנהלת חשבונות שחורה, קוד וכו'.

בשלב זה הצלחתי להשלים שלושה פרויקטים (זה לפי ההבנה שלי של "סופיות", כי כל מוצר ניתן לפתח יחסית בלי סוף).

• פרוייקט 0: זוהי סצנת תלת-ממד של אדריכל הדגמה שנכתבה ב-C# באמצעות מנוע המשחק Unity. עבור פלטפורמות macOS ו-Windows.
• משחק 1: משחק קונסולה Simple Snake (הידוע לכולם בתור "Snake") עבור Windows. כתוב ב-C.
• משחק 2: משחק קונסולה Crazy Tanks (הידוע לכולם בתור "Tanks"), כבר נכתב ב-C++ (באמצעות מחלקות) וגם תחת Windows.

פרויקט 0 הדגמת אדריכל

• פלטפורמה: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• שפה: C#
• מנוע משחק: אחדות
• הַשׁרָאָה: דארין לייל
• מאגר: GitHub

הדגמת אדריכל סצינה תלת מימדית

הפרויקט הראשון יושם לא ב-C/C++, אלא ב-C# באמצעות מנוע המשחק Unity. המנוע הזה לא היה תובעני בחומרה כמו מנוע לא מציאותי, וגם נראה לי קל יותר להתקנה ולשימוש. לא שקלתי מנועים אחרים.

המטרה ב-Unity מבחינתי לא הייתה לפתח איזה משחק. רציתי ליצור סצנה תלת מימדית עם איזושהי אופי. הוא, או יותר נכון היא (דגמנתי את הבחורה שהייתי מאוהב בה =) היה צריך לזוז וליצור אינטראקציה עם העולם החיצון. היה חשוב רק להבין מהי Unity, מהו תהליך הפיתוח, וכמה מאמץ נדרש כדי ליצור משהו. כך נולד פרויקט Architect Demo (השם הומצא כמעט מהשטויות). תכנות, דוגמנות, אנימציה, טקסטורינג לקחו לי כנראה חודשיים של עבודה יומיומית.

התחלתי בסרטוני הדרכה ביוטיוב על איך ליצור מודלים תלת מימדיים ב מַמחֶה. בלנדר הוא כלי חינמי נהדר עבור מודלים תלת מימדיים (ועוד) שאינו דורש התקנה. והנה חיכה לי הלם... מסתבר שדוגמנות, אנימציה, טקסטורה הם נושאים נפרדים ענקיים שאפשר לכתוב עליהם ספרים. זה נכון במיוחד לגבי הדמויות. כדי לדגמן אצבעות, שיניים, עיניים וחלקים אחרים בגוף, תזדקק לידע באנטומיה. כיצד מסודרים שרירי הפנים? איך אנשים זזים? הייתי צריך "להכניס" עצמות לכל יד, רגל, אצבע, פרקי אצבעות!

דגם את עצם הבריח, מנופי עצם נוספים, כך שהאנימציה תיראה טבעית. אחרי שיעורים כאלה, אתה מבין איזו עבודה ענקית עושים יוצרי סרטי אנימציה, רק כדי ליצור 30 שניות של וידאו. אבל סרטי תלת מימד נמשכים שעות! ואז אנחנו יוצאים מהאולמות ואומרים משהו כמו: "טא, סרט מצויר/סרט מחורבן! הם היו יכולים לעשות יותר טוב..." טיפשים!

ועוד משהו על תכנות בפרויקט הזה. כפי שהתברר, החלק המעניין ביותר עבורי היה החלק המתמטי. אם תריצו את הסצנה (קישור למאגר בתיאור הפרויקט), תבחינו שהמצלמה מסתובבת סביב דמות הילדה בכדור. כדי לתכנת סיבוב מצלמה כזה, הייתי צריך לחשב תחילה את הקואורדינטות של נקודת המיקום על המעגל (2D), ולאחר מכן על הכדור (3D). הדבר המצחיק הוא ששנאתי מתמטיקה בבית הספר וידעתי אותה במינוס. חלקית, כנראה, כי בבית הספר פשוט לא מסבירים לך איך לעזאזל מיושמת המתמטיקה הזו בחיים. אבל כשאתה אובססיבי למטרה שלך, לחלום, אז המוח מתנקה, מתגלה! ואתה מתחיל לתפוס משימות מורכבות כהרפתקה מרגשת. ואז אתה חושב: "ובכן, למה המתמטיקאי *אהוב* לא יכול היה לדעת לאן ניתן להישען את הנוסחאות האלה?".

חישוב נוסחאות לחישוב הקואורדינטות של נקודה על מעגל ועל כדור (מהמחברת שלי)

משחק 1

• פלטפורמה: Windows (נוסה ב-Windows 7, 10)
• שפה: אני חושב שזה נכתב ב-C טהור
• מנוע משחק: קונסולת ווינדוס
• הַשׁרָאָה: javidx9
• מאגר: GitHub

משחק נחש פשוט

סצינת התלת מימד היא לא משחק. בנוסף, מודלים והנפשה של אובייקטים תלת מימדיים (במיוחד דמויות) הוא ארוך וקשה. אחרי ששיחקתי עם Unity, הבנתי שאני חייב להמשיך, או יותר נכון להתחיל, מהבסיס. משהו פשוט ומהיר, אבל בו זמנית גלובלי, כדי להבין את עצם המבנה של משחקים.

ומה יש לנו פשוט ומהיר? זה נכון, קונסולה ודו מימד. ליתר דיוק, אפילו הקונסולה והסמלים. שוב, התחלתי לחפש השראה באינטרנט (באופן כללי, אני רואה באינטרנט את ההמצאה המהפכנית והמסוכנת ביותר של המאה ה-2). חפרתי סרטון של מתכנת אחד שיצר קונסולת טטריס. ובדמות משחקו, הוא החליט לכרות את ה"נחש". מהסרטון למדתי על שני דברים בסיסיים - לולאת המשחק (עם שלוש פונקציות / חלקים בסיסיים) והפלט למאגר.

לולאת המשחק עשויה להיראות בערך כך:

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

הקוד מציג את כל הפונקציה main() בבת אחת. ומחזור המשחק מתחיל לאחר ההערה המתאימה. יש שלוש פונקציות בסיסיות בלולאה: Input(), Logic(), Draw(). ראשית, קלט נתונים קלט (בעיקר שליטה על הקשות), לאחר מכן עיבוד הנתונים שהוזנו Logic, ולאחר מכן הצגת על המסך - Draw. וכך כל פריים. אנימציה נוצרת בדרך זו. זה כמו קריקטורות. בדרך כלל עיבוד נתוני הקלט לוקח הכי הרבה זמן, ולמיטב ידיעתי, הוא קובע את קצב הפריימים של המשחק. אבל כאן הפונקציה Logic() מהירה מאוד. לכן, קצב הפריימים חייב להיות נשלט על ידי הפונקציה Sleep() עם פרמטר gameSpeed, שקובע קצב זה.

מחזור משחק. תכנות נחש בפנקס רשימות

אם אתה מפתח משחק קונסולה סמלי, אז הצגת נתונים על המסך באמצעות פלט הזרם הרגיל 'cout' לא יעבוד - זה מאוד איטי. לכן, הפלט חייב להתבצע במאגר המסך. כל כך הרבה יותר מהר והמשחק יעבוד ללא תקלות. למען האמת, אני לא ממש מבין מה זה מאגר מסך ואיך הוא עובד. אבל אתן כאן דוגמה לקוד, ואולי מישהו בתגובות יוכל להבהיר את המצב.

השגת מאגר המסך (אם יורשה לי לומר זאת):

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

פלט ישיר למסך של שורה מסוימת scoreLine (השורה להצגת ציונים):

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

בתיאוריה, אין שום דבר מסובך במשחק הזה, זה נראה לי דוגמה טובה למשחק התחלתי. הקוד כתוב בקובץ אחד ומסודר במספר פונקציות. אין שיעורים, אין ירושה. אתה בעצמך יכול לראות הכל בקוד המקור של המשחק על ידי מעבר למאגר ב- GitHub.

משחק 2 Crazy Tanks

• פלטפורמה: Windows (נוסה ב-Windows 7, 10)
• שפה: C + +
• מנוע משחק: קונסולת ווינדוס
• הַשׁרָאָה: книга התחלת C++ דרך תכנות משחקים
• מאגר: GitHub

משחק טנקים מטורפים

הדפסת דמויות לקונסולה היא כנראה הדבר הפשוט ביותר שתוכלו להפוך למשחק. אבל אז מופיעה בעיה אחת: לדמויות יש גבהים ורוחב שונים (הגובה גדול מהרוחב). לפיכך, הכל ייראה לא פרופורציונלי, ותנועה למטה או למעלה תיראה הרבה יותר מהירה מאשר תנועה שמאלה או ימינה. אפקט זה בולט מאוד ב"נחש" (משחק 1). ל"טנקים" (משחק 2) אין חיסרון כזה, שכן הפלט שם מאורגן על ידי צביעת פיקסלים של המסך בצבעים שונים. אפשר לומר שכתבתי עיבוד. נכון, זה כבר קצת יותר מסובך, אם כי הרבה יותר מעניין.

למשחק הזה, זה יספיק לתאר את המערכת שלי להצגת פיקסלים על המסך. אני חושב שזה החלק העיקרי של המשחק. וכל השאר אתה יכול להמציא בעצמך.

אז מה שאתה רואה על המסך הוא רק קבוצה של מלבנים צבעוניים נעים.

סט מלבן

כל מלבן מיוצג על ידי מטריצה ​​מלאה במספרים. אגב, אני יכול להדגיש ניואנס אחד מעניין – כל המטריצות במשחק מתוכנתות כמערך חד מימדי. לא דו מימדי, אלא חד מימדי! מערכים חד מימדיים הרבה יותר קלים ומהירים לעבוד איתם.

דוגמה למטריצת טנק משחק

מייצג את המטריצה ​​של טנק משחק עם מערך חד-ממדי

דוגמה יותר ממחישה של ייצוג מטריצה ​​על ידי מערך חד מימדי

אבל הגישה לאלמנטים של המערך מתרחשת בלולאה כפולה, כאילו לא מדובר במערך חד מימדי, אלא במערך דו מימדי. זה נעשה כי אנחנו עדיין עובדים עם מטריצות.

מעבר של מערך חד מימדי בלולאה כפולה. Y הוא מזהה השורה, X הוא מזהה העמודה

שימו לב שבמקום מזהי המטריצה ​​הרגילים i, j, אני משתמש במזהים x ו-y. אז, נראה לי, נעים יותר לעין וברור יותר למוח. בנוסף, סימון כזה מאפשר להקרין בצורה נוחה את המטריצות המשמשות על צירי הקואורדינטות של תמונה דו-ממדית.

עכשיו לגבי פיקסלים, צבע ותצוגה. הפונקציה StretchDIBits (Header: windows.h; Library: gdi32.lib) משמשת לפלט. בין היתר מועברים לפונקציה זו: המכשיר בו מוצגת התמונה (במקרה שלי מדובר בקונסולת Windows), הקואורדינטות של תחילת הצגת התמונה, הרוחב/גובהה והתמונה. עצמו בצורה של מפת סיביות (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() . כלומר, מספר הבתים הנדרש שמור לאחסון מידע על כל הפיקסלים, שיוצג לאחר מכן על המסך.

יצירת מפת סיביות של 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 הוא אפור כהה, וכן הלאה. לפיכך, אנו יכולים לומר שיש לנו מטריצה ​​של שדה המשחק, כאשר כל מספר הוא סוג של צבע.

אז, יש לנו מטריצה ​​מספרית של כל שדה המשחק מצד אחד ומפת סיביות להצגת התמונה מצד שני. עד כה, מפת הסיביות "ריקה" - עדיין אין לה מידע על הפיקסלים של הצבע הרצוי. המשמעות היא שהשלב האחרון יהיה מילוי מפת הסיביות במידע על כל פיקסל בהתבסס על המטריצה ​​המספרית של שדה המשחק. דוגמה להמחשה של טרנספורמציה כזו היא בתמונה למטה.

דוגמה למילוי מפת סיביות (Pixel Matrix) במידע המבוסס על המטריצה ​​המספרית (Digital Matrix) של מגרש המשחקים (מדדי הצבע אינם תואמים את המדדים במשחק)

אציג גם חתיכת קוד אמיתי מהמשחק. למשתנה colorIndex בכל איטרציה של הלולאה מוקצה ערך (אינדקס צבע) מהמטריצה ​​המספרית של שדה המשחק (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. ללא קול! 😉 שאר החלקים הם רק מעוף.

כמובן, המשחק "Tanks" מעוצב הרבה יותר מסובך מ"הנחש". כבר השתמשתי בשפת C++, כלומר תיארתי אובייקטי משחק שונים עם מחלקות. יצרתי אוסף משלי - ניתן לראות את הקוד ב-headers/Box.h. אגב, לאוסף יש כנראה דליפת זיכרון. מצביעים משומשים. עבד עם זיכרון. אני חייב לומר שהספר עזר לי מאוד. התחלת C++ דרך תכנות משחקים. זוהי התחלה מצוינת למתחילים ב-C++. הוא קטן, מעניין ומאורגן היטב.

לקח בערך שישה חודשים לפתח את המשחק הזה. כתבתי בעיקר בזמן ארוחת צהריים וחטיפים בעבודה. הוא ישב במטבח המשרדי, דרס על אוכל וכתב קוד. או בבית לארוחת ערב. אז קיבלתי כאלה "מלחמות מטבח". כמו תמיד, השתמשתי באופן פעיל במחברת, וכל הדברים הרעיוניים נולדו בה.

בסוף החלק המעשי אשלוף כמה סריקות מהמחברת שלי. להראות מה בדיוק כתבתי, ציירתי, ספרתי, עיצבתי...

עיצוב תמונת טנק. וההגדרה של כמה פיקסלים כל מיכל צריך לתפוס על המסך

חישוב האלגוריתם והנוסחאות לסיבוב המיכל סביב צירו

דיאגרמה של האוסף שלי (זה עם דליפת הזיכרון, קרוב לוודאי). האוסף נוצר כרשימה מקושרת

ואלה ניסיונות חסרי תוחלת לדפוק בינה מלאכותית למשחק

Теория

"אפילו מסע של אלף מייל מתחיל בצעד הראשון" (חוכמה סינית עתיקה)

בואו נעבור מפרקטיקה לתיאוריה! איך אתה מוצא זמן לתחביב שלך?

1. קבע מה אתה באמת רוצה (אבוי, זה הכי קשה).
2. קבע סדרי עדיפויות.
3. להקריב את כל ה"מיותרים" למען סדרי עדיפויות גבוהים יותר.
4. התקדם לעבר המטרות שלך כל יום.
5. אל תצפו שיהיו שעתיים-שלוש של זמן פנוי לתחביב.

מצד אחד, אתה צריך לקבוע מה אתה רוצה ולתעדף. מצד שני, ניתן לנטוש חלק מהמקרים/פרויקטים לטובת סדרי עדיפויות אלו. במילים אחרות, תצטרך להקריב כל דבר "מיותר". שמעתי איפשהו שבחיים צריכות להיות מקסימום שלוש פעילויות עיקריות. אז תוכל להתמודד איתם בצורה הטובה ביותר. ופרויקטים/כיוונים נוספים יתחילו להעמיס על נדוש. אבל זה הכל, כנראה, סובייקטיבי ואינדיווידואלי.

יש כלל זהב מסוים: לעולם אל תהיה לך יום של 0%! למדתי על זה במאמר של מפתח אינדי. אם אתה עובד על פרויקט, אז עשה משהו בנידון כל יום. וזה לא משנה כמה אתה מרוויח. כתבו מילה אחת או שורת קוד אחת, צפו בסרטון הדרכה אחד, או תקעו מסמר אחד בלוח - פשוט עשו משהו. החלק הכי קשה זה להתחיל. ברגע שתתחיל, כנראה שתעשה קצת יותר ממה שרצית. אז אתה כל הזמן תתקדם לעבר המטרה שלך, ותאמין לי, מהר מאוד. אחרי הכל, הבלם העיקרי בכל הדברים הוא דחיינות.

וחשוב לזכור שאסור לזלזל ולהתעלם מה"נסורת" הפנוי של הזמן ב-5, 10, 15 דקות, חכו לכמה "לוגים" גדולים שימשכו שעה-שעתיים. אתה עומד בתור? תחשוב על משהו עבור הפרויקט שלך. אתה עולה במדרגות הנעות? רשום משהו במחברת. אתה אוכל באוטובוס? אוקיי, קרא איזה מאמר. נצל כל הזדמנות. הפסיקו לצפות בחתולים וכלבים ביוטיוב! אל תתעסק עם המוח שלך!

והאחרון. אם, לאחר קריאת מאמר זה, אהבת את הרעיון ליצור משחקים ללא שימוש במנועי משחק, אז זכור את השם קייסי מוראטורי. לבחור הזה יש сайт. בקטע "צפה -> פרקים קודמים" תמצאו מדריכי וידאו מדהימים בחינם כיצד ליצור משחק מקצועי מאפס. בחמישה שיעורים של Intro to C for Windows, אולי תלמדו יותר מאשר בחמש שנות לימוד באוניברסיטה (מישהו כתב על כך בתגובות מתחת לסרטון).

קייסי גם מסביר כי על ידי פיתוח מנוע משחק משלך, תהיה לך הבנה טובה יותר של כל המנועים הקיימים. בעולם המסגרת, שבו כולם מנסים לבצע אוטומציה, תלמדו איך ליצור, לא להשתמש. להבין את טבעם של מחשבים. ואתה גם תהפוך למתכנת הרבה יותר אינטליגנטי ובוגר - מקצוען.

בהצלחה בדרך שבחרת! ובואו נהפוך את העולם למקצועי יותר.

מחבר: גרנקין אנדריי, DevOps

מקור: www.habr.com