Skip to content
The Chat Archive
gemini-2.5-flash· Google LMArena Human Preference 140K

Napisz mi grę w kółko i krzyżyk w Kotlinie.

  1. User

    Napisz mi grę w kółko i krzyżyk w Kotlinie.

  2. Assistant

    Jasne! Oto prosta gra w Kółko i Krzyżyk (Tic-Tac-Toe) w Kotlinie, działająca w konsoli.

    Jak to działa:

    1. Tablica gry (Board): Reprezentowana jako dwuwymiarowa tablica Char (3x3), gdzie ' ' oznacza puste pole, 'X' ruch gracza X, a 'O' ruch gracza O.
    2. Wyświetlanie planszy: Funkcja printBoard ładnie formatuje i wyświetla obecny stan gry.
    3. Ruchy graczy: Gracze naprzemiennie wprowadzają numer wiersza i kolumny (od 1 do 3), aby zaznaczyć swoje pole.
    4. Walidacja ruchu: Program sprawdza, czy wprowadzone dane są liczbami, czy są w zakresie 1-3 i czy wybrane pole nie jest już zajęte.
    5. Sprawdzanie wygranej: Funkcja checkWin weryfikuje wszystkie możliwe kombinacje wygrywające (3 w rzędzie, 3 w kolumnie, 3 po przekątnych).
    6. Sprawdzanie remisu: Jeśli wszystkie pola zostaną zapełnione i nikt nie wygrał, gra kończy się remisem.
    7. Pętla gry: Gra kontynuuje się w pętli, dopóki ktoś nie wygra lub nie nastąpi remis.
    import java.util.InputMismatchException
    import java.util.Scanner
    
    // Reprezentacja planszy: 3x3 tablica znaków
    // ' ' - puste pole
    // 'X' - ruch gracza X
    // 'O' - ruch gracza O
    val board = Array(3) { Array(3) { ' ' } }
    
    // Bieżący gracz
    var currentPlayer = 'X'
    
    // Licznik ruchów (dla sprawdzenia remisu)
    var movesCount = 0
    
    fun main() {
        println("Witaj w Kółko i Krzyżyk!")
        println("Aby zagrać, podawaj numer wiersza i kolumny (np. 1 2 dla pola w pierwszym wierszu, drugiej kolumnie).")
    
        var gameOver = false
    
        // Główna pętla gry
        while (!gameOver) {
            printBoard() // Wyświetl aktualną planszę
            val (row, col) = getPlayerMove() // Pobierz ruch od gracza
    
            // Zaznacz pole na planszy
            board[row][col] = currentPlayer
            movesCount++
    
            // Sprawdź warunki zakończenia gry
            if (checkWin(currentPlayer)) {
                printBoard()
                println("\nGRATULACJE! Gracz $currentPlayer wygrał!")
                gameOver = true
            } else if (movesCount == 9) { // 9 ruchów = wszystkie pola zajęte
                printBoard()
                println("\nREMIS! Koniec gry.")
                gameOver = true
            } else {
                // Zmień gracza na następną turę
                currentPlayer = if (currentPlayer == 'X') 'O' else 'X'
            }
        }
        println("Dzięki za grę!")
    }
    
    /**
     * Wyświetla aktualny stan planszy.
     */
    fun printBoard() {
        println("\n-------------")
        for (row in 0 until 3) {
            print("| ")
            for (col in 0 until 3) {
                print("${board[row][col]} | ")
            }
            println()
            println("-------------")
        }
    }
    
    /**
     * Pobiera i waliduje ruch od bieżącego gracza.
     * Zwraca parę (wiersz, kolumna) jako indeksy 0-2.
     */
    fun getPlayerMove(): Pair<Int, Int> {
        val scanner = Scanner(System.`in`)
        var row: Int
        var col: Int
    
        while (true) {
            print("Gracz $currentPlayer, podaj swój ruch (wiersz i kolumna, np. 1 2): ")
            try {
                val input = scanner.nextLine()
                val parts = input.split(" ")
    
                if (parts.size != 2) {
                    println("Błąd: Proszę podać dwie liczby oddzielone spacją.")
                    continue
                }
    
                // Konwertuj wejście na indeksy 0-2 (użytkownik podaje 1-3)
                row = parts[0].toInt() - 1
                col = parts[1].toInt() - 1
    
                // Walidacja zakresu
                if (row !in 0..2 || col !in 0..2) {
                    println("Błąd: Wiersz i kolumna muszą być w zakresie od 1 do 3.")
                } else if (board[row][col] != ' ') {
                    // Walidacja zajętości pola
                    println("Błąd: To pole jest już zajęte. Wybierz inne.")
                } else {
                    return Pair(row, col) // Poprawny ruch
                }
            } catch (e: NumberFormatException) {
                println("Błąd: Nieprawidłowy format. Proszę wprowadzić liczby.")
            }
        }
    }
    
    /**
     * Sprawdza, czy bieżący gracz wygrał.
     * @param player Znak gracza ('X' lub 'O'), którego wygraną sprawdzamy.
     * @return True, jeśli gracz wygrał, w przeciwnym razie false.
     */
    fun checkWin(player: Char): Boolean {
        // Sprawdź wiersze
        for (i in 0 until 3) {
            if (board[i][0] == player && board[i][1] == player && board[i][2] == player) {
                return true
            }
        }
    
        // Sprawdź kolumny
        for (i in 0 until 3) {
            if (board[0][i] == player && board[1][i] == player && board[2][i] == player) {
                return true
            }
        }
    
        // Sprawdź przekątne
        if (board[0][0] == player && board[1][1] == player && board[2][2] == player) {
            return true // Główna przekątna
        }
        if (board[0][2] == player && board[1][1] == player && board[2][0] == player) {
            return true // Druga przekątna
        }
    
        return false
    }
    

    Jak uruchomić ten kod:

    1. Zapisz kod w pliku o nazwie TicTacToe.kt (lub innej z rozszerzeniem .kt).
    2. Otwórz terminal/konsolę.
    3. Przejdź do katalogu, w którym zapisałeś plik.
    4. Skompiluj kod za pomocą kompilatora Kotlin:
      kotlinc TicTacToe.kt -include-runtime -d TicTacToe.jar
      
    5. Uruchom skompilowaną grę:
      java -jar TicTacToe.jar
      

    Teraz możesz grać w Kółko i Krzyżyk w konsoli!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.