תכנת משחק משלך 2048 עם Java !: 8 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:11

מאת PranP1My (לא שלם) אתר עקוב אחר מאת המחבר:

אני אוהב את המשחק 2048. וכך החלטתי לתכנת גרסה משלי.

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

אולם לעת עתה, נתכנת את המשחק הטיפוסי שלך לשנת 2048.

בואו נתחיל!

(הערת צד: הוראה זו דורשת ידע מתון בתכנות - במיוחד עם Java)

שלב 1: חומרים

לא תצטרך הרבה לפרויקט הזה מכיוון שהוא רק הדרכה לתכנות.

חומרים:

• מחשב נייד
• ליקוי חמה (או כל IDE לבחירתך)

כן. זהו זה.

שלב 2: הכירו את התוכנית - מועצת המנהלים

העליתי את כל הקוד שלי ל- GitHub - בדוק אותו כאן:

חילקתי את המשחק ל -3 כיתות: לוח, אריח ומשחק.

גלשן:

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

בונים:

/ * קונסטרוקטור ברירת מחדל ללוח - מגדיר מטריצה 4x4 */

מועצה ציבורית () {…}

/ * בונה ללוח - מגדיר מטריצה עם גודל רשת שצוין */

לוח ציבורי (רשתות אינט) {…}

שיטות:

/ * שיטת Getter שמחזירה את הלוח */

אריח ציבורי getBoard () {…}

/ * שיטת Getter שמחזירה את הציון */

public int getScore () {…}

/ * מוצא את האריח הגבוה ביותר בלוח ומחזיר אותו */

public int getHighTile () {…}

/ * מדפיס את הלוח על הקונסולה - למטרות בדיקה */

הדפסה חללית לציבור () {…}

/ * מחזירה את הלוח כמחרוזת - בשימוש ב- GUI */

מחרוזת ציבורית toString () {…}

/ * מוליד 2 (או 4) בחלל ריק ממש בזמן שנעשה מהלך */

ריקון חלל ציבורי () {…}

/ * בודק אם הלוח הושחר לחלוטין ואם כן, הוא ידחוף את השחקנים להפעיל מחדש */

blackOut בוליאני ציבורי () {…}

/ * בודק אם המשחק הסתיים - כאשר הלוח מושחר ואף אחד מהאריחים לא יכול לשלב */

game boolean publicOver () {…}

/ * נקרא כאשר לוחצים על 'w' או חץ למעלה - קוראים 'verticalMove' לכל אריח בלוח עם פרמטר 'למעלה' */

ביטול הציבור () {…}

/ * נקרא כאשר נלחצים על החץ 's' או כלפי מטה - קוראים 'verticalMove' לכל אריח בלוח עם הפרמטר 'למטה' */מטה פומבי למטה () {…}

/ * נקרא כאשר לוחצים על 'd' או על חץ ימינה - קוראים 'horizontalMove' לכל אריח בלוח עם הפרמטר 'right' */right void right () {…}

/ * נקרא כאשר לוחצים על 'a' או על חץ שמאלה - קוראים 'horizontalMove' לכל אריח בלוח עם הפרמטר 'שמאל' */

ריק ציבורי נותר () {…}

/* משווה שני ערכי אריחים יחד ואם הם זהים או אם אחד שווה ל 0 (אריח רגיל) - הערכים שלהם מתווספים (בתנאי שהאריחים שאנו משווים הם שני אריחים שונים והם נעים לכיוון המתאים) - נע רקורסיבי בשורה */

public void horizontalMove (int intry, int col, direction String) {…}

/* משווה שני ערכי אריחים יחד ואם הם זהים או אם אחד שווה ל 0 (אריח רגיל) - הערכים שלהם מתווספים (בתנאי שהאריחים שאנו משווים הם שני אריחים שונים והם נעים לכיוון המתאים) - עובר רקורסיבית דרך העמודה */

public void verticalMove (int intry, int col, direction string) {…}

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

שלב 3: הכירו את התוכנית - אריח

אָרִיחַ:

תיאור: מחלקת האריחים עוסקת באריחים הבודדים, והיא הקטנה מבין כל המחלקות. לכל אריח יש ערך שלם וצבע. יש לו שני בונים היוצרים אריחים בעלי ערך 0 (ברירת מחדל) או ערך #. השיטות ברובן מסבירות את עצמן, כאשר שיטות 'גטר' ו'סתר 'מהוות חלק ניכר מהסכום הכולל.

בונים:

/ * בונה אריח בסיסי בערך 0 */

אריח ציבורי () {…}

/ * בונה אריח עם ערך של מספר */

אריח ציבורי (מספר int) {…}

שיטות:

/ * מקבל את ערך האריח */

public int getValue () {…}

/ * קובע את ערך האריח - משמש בעת הוספת שני אריחים יחדיו */

public void setValue (ערך int) {…}

/ * מייצג את האריח כמחרוזת - בשימוש ב- GUI */

מחרוזת ציבורית toString () {…}

/ * קובע את צבע האריח בהתאם לערכו */

public void setColor () {…}

/ * מקבל את צבע האריח */

public void getColor () {…}

שלב 4: הכירו את התוכנית - משחק

מִשְׂחָק

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

בונים:

אף אחד

שיטות:

/ * מגדיר את GUI בגדלים מתאימים ומוסיף מאזין מקשים */

פסל סטטי ציבורי setUpGUI () {…}

/ * בודק אם נלחצים על מקשי wasd או חץ ומבצע את הפעולות המתאימות - מעדכן את JFrame בכל מהלך */

public void keyPressed (KeyEvent e) {…}

/ * צובע את ה- GUI עם סדרת מחרוזות, הלוח, האריחים ומבטיח שהם נצבע מחדש כאשר המשחק נגמר */

צבע חלל ציבורי (גרפיקה ז) {…}

/ * מצייר אריח בודד - נקרא משיטת הצבע */

public void drawTiles (גרפיקה g, אריח אריח, int x, int y) {…}

/ * שיטה עיקרית - מגדירה את ה- GUI ומתחילה את המשחק */

פסל סטטי ציבורי (String args) {…}

שלב 5: שיטות חשובות - תנועה

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

private void verticalMove (שורה int, int col, כיוון מחרוזת)

{Tile initial = board [border] [col]; השוואת אריחים = לוח [שורה] [קול]; if (initial.getValue () == 0 || initial.getValue () == Compare.getValue ()) {if (שורה> גבול || (direction.equals ("למטה") && (שורה <גבול))) {int addScore = initial.getValue () + compar.getValue (); אם (initial.getValue ()! = 0) {score += addScore; } initial.setValue (addScore); Compare.setValue (0); }} אחר {if (direction.equals ("למטה")) {border--; } אחר {גבול ++; } verticalMove (שורה, col, כיוון); }}

השיטה לעיל, verticalMove, נקראת בשיטות 'למעלה' ו'מטה '. בואו נסתכל על שיטת 'למעלה'.

ביטול הציבור ()

{for (int i = 0; i <grids; i ++) {border = 0; עבור (int j = 0; j <grids; j ++) {if (לוח [j] .getValue ()! = 0) {if (גבול <= j) {verticalMove (j, i, "למעלה"); }}}}}

שיטה זו עוברת על כל הלוח וקוראת ל- verticalMove לכל אריח עם הפרמטר "למעלה". לאחר מכן, verticalMove משווה את האריח במיקום 'j' ו- 'i' עם האריח במיקום 'גבול' ו- 'i'. אם השניים שווים, הם משולבים. אם הם לא, אריח הגבול מוגדל ב- 1 (מכיוון שהפרמטר במקום הוא 'למעלה'), ו- verticalMove נקרא שוב.