צור משחק Tic-Tac-Toe ב-C++
הדוגמה הבאה מספקת את העקרונות הבסיסיים של הכנת המשחק האינטראקטיבי הזה לשני שחקנים. הוא מציג גישה פשוטה וקלה לתכנות אותו עם C++ ומספק קוד מקור מתועד היטב כדי לחיות מחדש את אתגרי הילדות האלה עם חברים בפורמט חדש ודיגיטלי. תן לנו לראות את הקוד הבא.
דוגמה: Tic-Tac-Toe מבוסס קונסולות בסיסי ללא שימוש במערך הדו-ממדי
בדוגמה זו, נשתמש במערך דו-ממדי, בפונקציות ובתנאים של if-else כדי ליצור את המשחק טיק-טק ב-C++. במשחק זה, שני שחקנים רשאים להזין את המהלכים שלהם בתורו, והוא קובע את מצב המשחק על ידי בדיקת מנצח או תיקו. ראה את הקוד הבא:
#include
באמצעות מרחב שמות std ;
בָּטֵל לוח שרוך ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) ;
bool isMoveValid ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] , int שׁוּרָה , int קול ) ;
bool isBoardFull ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) ;
לְהַשְׁחִיר checkWiner ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) ;
int רָאשִׁי ( ) {
לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int שׁוּרָה , קול ;
לְהַשְׁחִיר נגן הנוכחי = 'איקס' ;
בזמן ( נָכוֹן ) {
לוח שרוך ( גלשן ) ;
cout << 'שחקן ' << נגן הנוכחי << התור של '. היכנס לשורה (1-3) ולעמודה (1-3): ' ;
אֲכִילָה >> שׁוּרָה >> קול ;
שׁוּרָה --;
קול --;
אם ( isMoveValid ( גלשן , שׁוּרָה , קול ) ) {
גלשן [ שׁוּרָה ] [ קול ] = נגן הנוכחי ;
לְהַשְׁחִיר זוֹכֵה = checkWiner ( גלשן ) ;
אם ( זוֹכֵה != '' ) {
לוח שרוך ( גלשן ) ;
cout << 'שחקן ' << זוֹכֵה << 'הוא מנצח! \n ' ;
לשבור ;
}
אם ( isBoardFull ( גלשן ) ) {
לוח שרוך ( גלשן ) ;
cout << 'זו עניבה! \n ' ;
לשבור ;
}
נגן הנוכחי = ( נגן הנוכחי == 'איקס' ) ? 'או' : 'איקס' ;
} אַחֵר {
cout << 'מהלך לא חוקי. בחר תא אחר. \n ' ;
} }
לַחֲזוֹר 0 ;
}
בָּטֵל לוח שרוך ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) {
cout << 'ב| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
cout << ' _____________________ \n ' ;
ל ( int M = 0 ; M < 3 ; M ++ ) {
cout << M + 1 << '|' ;
ל ( int ט = 0 ; ט < 3 ; ט ++ ) {
cout << '' << גלשן [ M ] [ ט ] ;
אם ( ט < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
אם ( M < 2 ) cout << '__________________________ \n ' ;
}
cout << ' \n ' ; }
bool isMoveValid ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] , int שׁוּרָה , int קול ) {
לַחֲזוֹר ( שׁוּרָה >= 0 && שׁוּרָה < 3 && קול >= 0 && קול < 3 && גלשן [ שׁוּרָה ] [ קול ] == '' ) ;
}
bool isBoardFull ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) {
ל ( int M = 0 ; M < 3 ; M ++ ) {
ל ( int ט = 0 ; ט < 3 ; ט ++ ) {
אם ( גלשן [ M ] [ ט ] == '' ) {
לַחֲזוֹר שֶׁקֶר ;
} } }
לַחֲזוֹר נָכוֹן ; }
לְהַשְׁחִיר checkWiner ( לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] ) {
ל ( int M = 0 ; M < 3 ; M ++ ) {
אם ( גלשן [ M ] [ 0 ] == גלשן [ M ] [ 1 ] && גלשן [ M ] [ 1 ] == גלשן [ M ] [ 2 ] && גלשן [ M ] [ 0 ] != '' ) {
לַחֲזוֹר גלשן [ M ] [ 0 ] ;
}
אם ( גלשן [ 0 ] [ M ] == גלשן [ 1 ] [ M ] && גלשן [ 1 ] [ M ] == גלשן [ 2 ] [ M ] && גלשן [ 0 ] [ M ] != '' ) {
לַחֲזוֹר גלשן [ 0 ] [ M ] ;
} }
אם ( גלשן [ 0 ] [ 0 ] == גלשן [ 1 ] [ 1 ] && גלשן [ 1 ] [ 1 ] == גלשן [ 2 ] [ 2 ] && גלשן [ 0 ] [ 0 ] != '' ) {
לַחֲזוֹר גלשן [ 0 ] [ 0 ] ;
}
אם ( גלשן [ 0 ] [ 2 ] == גלשן [ 1 ] [ 1 ] && גלשן [ 1 ] [ 1 ] == גלשן [ 2 ] [ 0 ] && גלשן [ 0 ] [ 2 ] != '' ) {
לַחֲזוֹר גלשן [ 0 ] [ 2 ] ;
}
לַחֲזוֹר '' ;
}
להלן פירוט של הפונקציונליות שלו:
ה-'#include
ישנם ארבעה אבות טיפוס של פונקציות בתוכנית זו - הם drawBoard(), isMoveValid(), isBoardFull() ו-checkWinner(). הצהרת הפונקציה ידועה בתור אב טיפוס של פונקציה. למרות שזה מגיע אחרי הפונקציה הראשית בתוכנית, זה ישמש. הפונקציה העיקרית מכילה את לולאת המשחק וההיגיון לניהול התורות והמהלכים של השחקנים. בתוך הפונקציה הראשית, לוח המשחק מאותחל עם רווחים.
לְהַשְׁחִיר גלשן [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
לאחר מכן, שני משתני שורה וקול מוגדרים לאחסון קלט המהלך של השחקן. ה-'char currentPlayer = 'X';' מגדיר שהשחקן 'X' הולך ראשון.
כעת, לולאת המשחק בעוד (האמיתית) מתחילה, והיא פועלת עד שיש מנצח או תיקו. לולאת 'while' זו קוראת ל-'drawBoard();' כדי להציג את הלוח. לאחר הצגת הלוח במסוף, המשתמש מתבקש לבחור תא לסימון בהצהרת הקוד הבאה:
cout << 'שחקן ' << נגן הנוכחי << התור של '. הזן שורה ועמודה (1-3): ' ;
השחקן מזין את המהלך שלו ב-'cin >> row >> col;'.
בבחירת תא לסימון, התוכנית תוודא תחילה את תקפות הקלט, ותוודא שהתא עדיין לא מלא על ידי קריאה לפונקציה isMoveValid() .
גלשן [ שׁוּרָה ] [ קול ] = נגן הנוכחי ;הצהרה זו מציבה את חותמו של השחקן על הלוח.
לְהַשְׁחִיר זוֹכֵה = checkWiner ( גלשן ) ;אם ( זוֹכֵה != '' ) {
לוח שרוך ( גלשן ) ;
cout << 'שחקן ' << זוֹכֵה << 'מנצח! \n ' ;
הצהרות אלו בודקות מנצח בכל פעם ששחקן מסמן ערך על הלוח. שם המנצח יוכרז אם יש זוכה, והתוכנית תצא מלולאת המשחק.
אם ( isBoardFull ( גלשן ) ) {הצהרה זו בודקת תיקו. מצב השוויון מתרחש במקרה בו הלוח מלא ואין מנצח. במקרה הזה, 'זו עניבה!' מודפס על המסך.
נגן הנוכחי = ( נגן הנוכחי == 'איקס' ) ? 'או' : 'איקס' ;הצהרה זו מחליפה את השחקנים כדי לתת לכל שחקן הזדמנות לשחק בתורו.
cout << 'מהלך לא חוקי. בחר תא אחר. \n ' ;אם המהלך אינו חוקי, המשתמש מתבקש להזין שוב ולבחור כל תא אחר.
לאחר הפונקציה 'הראשית', הגדרות הפונקציה עבור אבות הטיפוס של הפונקציות שהוכרזו קודם לכן יתחילו. הפונקציה הראשונה שמוגדרת כאן היא drawBoard() המשמשת לצייר את לוח הטיק-טק אל הקונסולה. הפונקציה drawBoard() מדפיסה את המצב הנוכחי של הלוח, כולל קווי רשת.
הפונקציה הבאה שמוגדרת כאן היא isMoveValid(). פונקציה זו משמשת כדי לקבוע אם מהלך מותר הן בתוך הלוח והן בתא ריק. הפונקציה isBoardFull() משמשת כדי לבדוק אם הלוח עדיין מלא. זהו תנאי למצב תיקו כאשר אין מנצח. ה-isBoardFull() בודק אם כל המיקומים בלוח מלאים, מה שמעיד על תיקו אם אין מנצח. אם יש מנצח, ניתן לקבוע זאת באמצעות הפונקציה checkWinner() . ה-checkWinner() בודק את כל שורות הזכייה הפוטנציאליות עבור סימן של אותו שחקן ('X' או 'O') ומחזיר את הסימן של השחקן הזוכה אם נמצא או תו רווח ' ' אם אין עדיין מנצח. להלן הפלט של התוכנית. זה מראה כל תור מכל שחקן.
ראשית, הלוח ברור; הנגן 'X' מתבקש לבחור את התא שיסומן. כאן, שחקן 'X' נכנס 2 ו-2. התאים של שורה 2 ועמודה 2 מסומנים. עיין בלוח המסומן להלן:
כעת, תורו של השחקן O. הנגן מתבקש לבחור תא שיסומן. שחקן 'O' בוחר 1 עבור השורה ו-1 עבור העמודה. התא הנבחר מסומן עבור שחקן 'O' כפי שמוצג בקטע הפלט הבא:
כל התורים של כל שחקן יפעלו על פי אותה דפוס. זה תורו של שחקן X, והשחקן בוחר 1 עבור השורה ו-2 עבור העמודה. עיין בתמונות הפלט הבאות:
כעת, התור הוא לשחקן 'O'. השחקן בוחר 1 עבור השורה ו-3 עבור העמודה.
התור הבא הוא שוב על שחקן 'X'. השחקן בוחר 3 עבור השורה ו-1 עבור העמודה.
שחקן 'O' בוחר 3 עבור השורה ו-2 עבור העמודה.
שחקן 'X' בוחר את השורה השנייה ואת העמודה השלישית.
שחקן 'O' בוחר כעת את השורה השנייה ואת העמודה הראשונה.
שחקן 'X' בוחר הפעם בשורה השלישית ובעמודה השלישית.
אף שחקן לא יכול היה לעשות קו אופקית, אנכית או אלכסונית, אז זה תיקו. אין מנצח עבור מערך התשומות הנבחר.
בסך הכל, הקוד כולל לולאת משחק ראשית שאחראית לטיפול במצב המשחק וקלט המשתמש, יחד עם מספר פונקציות שירות המשמשות לצייר את הלוח, לאמת את המהלכים, לבדוק אם יש לוח מלא ולקבוע אם יש מנצח .
סיכום
פיתוח משחק תקלות באמצעות C++ הוא תרגיל מעשי מצוין לחיזוק כישורי התכנות שלך. המאמר מסביר במדויק כיצד ליצור טיק-טק ב-C++. ההדרכה המפורטת במאמר זה כללה מערך דו-ממדי, פונקציות ותנאים 'אם עוד' כדי שהקוראים יוכלו להבין את מכניקת המשחק, אינטראקציות המשתמש ומבנה קוד יעיל. ההליכה המפורטת של הקוד וההסבר על הפונקציות החיוניות למשחק הליבה מציידות את הקוראים בתובנות שלא יסולא בפז הן לגבי שיטות התכנות C++ והן במורכבויות של פיתוח משחק פשוט.