משחק Java למתחילים

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

1. המשך מאמר זה
2. 2048

טיק טק נראה לי כמו המשחק הפשוט ביותר, אז החלטתי לחלק את המשימה למספר משימות משנה:

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

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

1. שדה
2. שני שחקנים מתחלפים, אחד מעביר הצלבה, השני אפס. זה פשוט.

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

String[][] strings = {{"O", "O", "_"},
                    {"_", "X", "O"},
                    {"X", "X", "X"},
for (String [] ss : strings){
    for (String s : ss) System.out.print(s + " ");
    System.out.println(); //для перевода строки
}

המסך יציג:

O O _
_ X O
X X X

אבל בנוסף לתצוגה, יש לנו גם השוואת ערכים, וכאן כבר אפשריות אפשרויות. אתה יכול להשוות מחרוזות, אתה יכול ליצור מחלקת ספירה מיוחדת ( enum), אבל אני מעדיף להשוות מספרים, ולהחליף אותם ב-"X" ו-"O" רק כשהם מוצגים על המסך. תן לזה להיות, למשל, 1 - "X", 2 - "O", 0 - "_". אז איך בודקים שדה עבור התאמת X או O משולשת?
האלגוריתם הראשון הוא בדיקת כל השדה

int[][] canvas = {{00, 01, 02},
                 {10, 11, 12},
                 {20, 21, 22}}

שילובים מנצחים:

00-01-02, 10-11-12, 20-21-22, 00-10-20, 01-11-21, 02-12-22, 00-11-22, 20-11-02 — всего 8.

בודקים על ידי השוואת מספרים, אבל מסתבר שצריך לבדוק את כל השדה, כל 8 השילובים, בכל פעם. כמובן, זה לא הרבה, זה לא חיפוש אחר מספרי ארמסטרונג בטווח שבין 0 ל-1 מיליארד, יש כאן מעט יותר מאשר אין חישובים, אבל אתה עדיין רוצה משהו אופטימלי יותר מאשר לבדוק את כל התחום. הרעיון השני שעלה לי היה לבדוק רק את התא שסומן על המהלך הקודם, כך שעדיין נוכל לקבוע את המנצח, כי נדע מי ביצע את המהלך הזה. כך, במקום כל 8 השילובים, נקבל רק 2, 3 או 4 שילובים, תלוי בתא, ראה את התמונה: עכשיו צריך להבין איך לקבוע איזה שילוב צריך להיות מושק? כאן הבנתי ששימוש במערך דו מימדי אינו נוח במיוחד. החלטתי לבדוק אפשרויות אחרות. בהתחלה עלה לי הרעיון שאפשר לשמור את השדה במספר בן תשע ספרות, למשל, אותו שדה שהצגנו על המסך יכול להיכתב כך: 220012111, אני אסביר באצבעותי מה זה הוא... הקוד זהה, 1 - "X", 2 - "O" , 0 – " ", כלומר 220012111 = "OO__XOXXX", או אם אחרי כל ספרה שלישית אתה מכניס מעבר שורה ומוסיף רווחים עבור בְּהִירוּת:

О О _
_ Х О
Х Х Х

כאן שוב, נוח לאחסון, הומצא מכשיר לתצוגה, אבל לא נוח להשוואה! הפתרון נמצא כשסיפרתי את התאים 1-9, אז חשבתי, כי בתכנות הספירה לאחור מתחילה מ-0 וממספרת אותו כמו בתמונה.לא שמת לב לשום מוזרויות? אם תסתכל על התמונה למעלה, יתברר שלפתרונות עם 2 צירופים יש מספר סידורי אי זוגי, ל-4 צירופים יש מספר סידורי 4, ל-3 צירופים יש את השאר. אז הגעתי למסקנה שצריך לשמור על מגרש המשחקים במערך מספרים קבוע: איטרציה פשוטה בין מספרים, יכולת השוואה לפי האלגוריתם שנבחר, פלט פשוט למסך. לגבי אלגוריתם ההשוואה עצמו. בוא נלך לפי הסדר: בכל האפשרויות יש בדיקה של השורה והעמודה, אנחנו בודקים רק אותן. אם החיפוש לא מתקבל, נבדוק את מספר התא זוגי/אי-זוגי, אם הוא אי-זוגי, אז נחזור למשחק, אין טעם לבדוק יותר, אם הוא זוגי, בודקים אם התא הזה שוכב על באלכסון שמאלי, למספרים של האלכסון הזה כאשר מחלקים ב-4 יש שארית של 0. אם הוא שקר, נבדוק התאמות, אם לא נמצאו התאמות, אז נבדוק את המספר 4, אם לא, נחזור למשחק, אם כן, אנחנו עוברים יותר על הקוד ומחזירים את התוצאה של בדיקת האלכסון האחרון. כנראה שלאדם לא מוכן, קשה להבין את זה לאחר קריאת מכלול האותיות למעלה, אבל מישהו יכול לומר שיש הרבה אותיות בקוד עצמו, מה שיכול להיות פשוט יותר, אני אשמח לדון בזה. סידרנו את התחום, עכשיו אנחנו צריכים להתמודד עם שני משתמשים שמתחלפים ולכל אחד מהם יש סימן משלו, X או O. בשלב הראשון, אין לנו שום פונקציונליות מרובה משתמשים, אז הדרך הקלה ביותר תהיה להשתמש בסמלים אחד אחד. X תמיד עושה את המהלך הראשון, O תמיד עושה את השני, ואז X שוב, וכן הלאה. זה מתחנן לסימון ( true/false ), ואם נכון – אז השחקן הנוכחי הוא X, אם false – אז O ובתחילת כל מהלך דגל=!flag נשאר איכשהו לקבל אות מהשחקנים לגביו תא שהם בוחרים. כאן נצטרך הבלתי נשכחים שלנו. BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); השחקנים יכניסו את מספרי התאים לתוך הקונסולה, ולחיצה על Enter תעשה מהלך. התא המתאים למספר שהוזן ישנה את ערכו מ-0 ל-1 או 2, בהתאם למצב הנוכחי של תיבת הסימון, שנדון בפסקה למעלה. כאן חשוב לאמת את הקלט כדי שאף אחד לא יוכל לשנות X ל-O כשהתא כבר מלא :) מה הנגן יכול להכניס לקונסולה?

1. שורה ריקה
2. אותיות, סימני פיסוק, סוגריים... במילה אחת, לא מספרים
3. מספרים שגויים - שלילי או מחוץ לגודל המערך, תאים תפוסים.

השיטה הסטנדרטית לקבלת ספרה ממחרוזת היא השיטה הסטטית parseInt של המחלקה Integer. Integer.parseInt("2");היא זורקת חריגה NumberFormatExceptionאם היא לא יכולה לקבל ספרה ממחרוזת נתונה. אנו יכולים לספק הגנה משתי הנקודות הראשונות על ידי יירוט החריג הזה. לנקודה השלישית הייתי יוצר שיטה אחרת שבודקת את הערך שהוזן, אבל הכי נכון יהיה להעביר את בקשת המחרוזת למתודה נפרדת שבה יתבצע אימות והיא תחזיר רק מספר. לסיכום, יצרנו שדה, הכנו שיטה שמציגה אותו, הכנו שיטה שבודקת "האם השחקן הזה ניצח בשעה?", ואימתנו את המספרים שהוזנו. נשאר מעט מאוד לעשות, לבדוק תיקו - שיטה נפרדת שעוברת במערך ומחפשת 0, ומציגה את תוצאות המשחק. זה הכל, הקוד מוכן, המשחק התברר כקטן, רק מחלקה אחת, אז משפרי העתקה קשוחים יכולים, בלי להבין, פשוט להעתיק הכל לפרויקט שלהם ולהפעיל אותו לבד, אני הייתי כזה בעצמי, אבל עכשיו אני משתדל לא לעשות את זה ולא לאף אחד אני ממליץ על זה :) בהצלחה לכולם בלימוד JAVA! נ.ב שאר הנקודות - מרובה משתתפים ומסד נתונים יגיעו בהמשך, כבר התחלתי ללמוד את החומר :)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class GameField {

    static int [] canvas = {0,0,0,
                            0,0,0,
                            0,0,0};

    //012, 345, 678, 036, 147, 258, 048, 246
    public static void main(String[] args){

        boolean b;
        boolean isCurrentX = false;
        do {
            isCurrentX = !isCurrentX;
            drawCanvas();
            System.out.println("mark " + (isCurrentX ? "X" : "O"));
            int n = getNumber();
            canvas[n] = isCurrentX ? 1 : 2;
            b = !isGameOver(n);
            if (isDraw()){
                System.out.println("Draw");
                return;
            }
        } while (b);
        drawCanvas();
        System.out.println();

        System.out.println("The winner is " + (isCurrentX ? "X" : "O") + "!");
    }

    static int getNumber(){
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true){
            try {
                int n = Integer.parseInt(reader.readLine());
                if (n >= 0 && n < canvas.length && canvas[n]==0){
                    return n;
                }
                System.out.println("Choose free cell and enter its number");
            } catch (NumberFormatException e) {
                System.out.println("Please enter the number");
            } catch (IOException e) {
            }
        }
    }

    static boolean isGameOver(int n){
        // 0 1 2
        // 3 4 5
        // 6 7 8
        //поиск совпадений по горизонтали
        int row = n-n%3; //номер строки - проверяем только её
        if (canvas[row]==canvas[row+1] &&
                canvas[row]==canvas[row+2]) return true;
        //поиск совпадений по вертикали
        int column = n%3; //номер столбца - проверяем только его
        if (canvas[column]==canvas[column+3])
            if (canvas[column]==canvas[column+6]) return true;
        //мы здесь, значит, первый поиск не положительного результата
        //если meaning n находится на одной из граней - возвращаем false
        if (n%2!=0) return false;
        //проверяем принадлежит ли к левой диагонали meaning
        if (n%4==0){
            //проверяем есть ли совпадения на левой диагонали
            if (canvas[0] == canvas[4] &&
                    canvas[0] == canvas[8]) return true;
            if (n!=4) return false;
        }
        return canvas[2] == canvas[4] &&
                canvas[2] == canvas[6];
    }

    static void drawCanvas(){
        System.out.println("     |     |     ");
        for (int i = 0; i < canvas.length; i++) {
            if (i!=0){
                if (i%3==0) {
                    System.out.println();
                    System.out.println("_____|_____|_____");
                    System.out.println("     |     |     ");
                }
                else
                    System.out.print("|");
            }

            if (canvas[i]==0) System.out.print("  " + i + "  ");
            if (canvas[i]==1) System.out.print("  X  ");
            if (canvas[i]==2) System.out.print("  O  ");
        }
        System.out.println();
        System.out.println("     |     |     ");
    }

    public static boolean isDraw() {
        for (int n : canvas) if (n==0) return false;
        return true;
    }
}