Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.0-flash-001· GoogleHugging Face LMArena Human Preference 140K

wygeneruj kod na prostą grę snake

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash’s answer.
  1. User

    wygeneruj kod na prostą grę snake

  2. Gemini Assistant

    Oczywiście, oto prosty kod gry Snake w Pythonie z użyciem biblioteki Pygame:

    import pygame
    import time
    import random
    
    # Inicjalizacja Pygame
    pygame.init()
    
    # Ustawienia ekranu
    szerokosc_ekranu = 600
    wysokosc_ekranu = 480
    ekran = pygame.display.set_mode((szerokosc_ekranu, wysokosc_ekranu))
    pygame.display.set_caption("Snake")
    
    # Kolory
    bialy = (255, 255, 255)
    czarny = (0, 0, 0)
    czerwony = (255, 0, 0)
    zielony = (0, 255, 0)
    niebieski = (0, 0, 255)
    
    # Ustawienia węża
    rozmiar_bloku = 20
    predkosc = 15
    
    # Czcionki
    czcionka = pygame.font.SysFont(None, 25)
    
    # Funkcje pomocnicze
    def wyswietl_wynik(wynik):
        tekst = czcionka.render("Wynik: " + str(wynik), True, bialy)
        ekran.blit(tekst, [0, 0])
    
    def rysuj_weza(rozmiar_bloku, lista_weza):
        for x in lista_weza:
            pygame.draw.rect(ekran, zielony, [x[0], x[1], rozmiar_bloku, rozmiar_bloku])
    
    def wiadomosc(msg, kolor):
        tekst = czcionka.render(msg, True, kolor)
        tekst_rect = tekst.get_rect(center=(szerokosc_ekranu / 2, wysokosc_ekranu / 2))
        ekran.blit(tekst, tekst_rect)
    
    def petla_gry():
        koniec_gry = False
        zamknij_gre = False
    
        # Pozycja początkowa węża
        x1 = szerokosc_ekranu / 2
        y1 = wysokosc_ekranu / 2
    
        # Zmiana pozycji
        x1_zmiana = 0
        y1_zmiana = 0
    
        # Lista węża
        lista_weza = []
        dlugosc_weza = 1
    
        # Pozycja jedzenia
        jedzenie_x = round(random.randrange(0, szerokosc_ekranu - rozmiar_bloku) / 20.0) * 20.0
        jedzenie_y = round(random.randrange(0, wysokosc_ekranu - rozmiar_bloku) / 20.0) * 20.0
    
        while not koniec_gry:
    
            while zamknij_gre == True:
                ekran.fill(czarny)
                wiadomosc("Przegrałeś! Naciśnij Q, aby wyjść, lub C, aby zagrać ponownie", czerwony)
                wyswietl_wynik(dlugosc_weza - 1)
                pygame.display.update()
    
                for event in pygame.event.get():
                    if event.type == pygame.KEYDOWN:
                        if event.key == pygame.K_q:
                            koniec_gry = True
                            zamknij_gre = False
                        if event.key == pygame.K_c:
                            petla_gry()
    
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    koniec_gry = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        x1_zmiana = -rozmiar_bloku
                        y1_zmiana = 0
                    elif event.key == pygame.K_RIGHT:
                        x1_zmiana = rozmiar_bloku
                        y1_zmiana = 0
                    elif event.key == pygame.K_UP:
                        y1_zmiana = -rozmiar_bloku
                        x1_zmiana = 0
                    elif event.key == pygame.K_DOWN:
                        y1_zmiana = rozmiar_bloku
                        x1_zmiana = 0
    
            if x1 >= szerokosc_ekranu or x1 < 0 or y1 >= wysokosc_ekranu or y1 < 0:
                zamknij_gre = True
    
            x1 += x1_zmiana
            y1 += y1_zmiana
            ekran.fill(czarny)
            pygame.draw.rect(ekran, czerwony, [jedzenie_x, jedzenie_y, rozmiar_bloku, rozmiar_bloku])
            glowa_weza = []
            glowa_weza.append(x1)
            glowa_weza.append(y1)
            lista_weza.append(glowa_weza)
            if len(lista_weza) > dlugosc_weza:
                del lista_weza[0]
    
            for x in lista_weza[:-1]:
                if x == glowa_weza:
                    zamknij_gre = True
    
            rysuj_weza(rozmiar_bloku, lista_weza)
            wyswietl_wynik(dlugosc_weza - 1)
            pygame.display.update()
    
            if x1 == jedzenie_x i y1 == jedzenie_y:
                jedzenie_x = round(random.randrange(0, szerokosc_ekranu - rozmiar_bloku) / 20.0) * 20.0
                jedzenie_y = round(random.randrange(0, wysokosc_ekranu - rozmiar_bloku) / 20.0) * 20.0
                dlugosc_weza += 1
    
            clock.tick(predkosc)
    
        pygame.quit()
        quit()
    
    # Ustawienie zegara
    clock = pygame.time.Clock()
    
    # Uruchomienie gry
    petla_gry()
    

    Jak uruchomić:

    1. Zainstaluj Pygame:
      pip install pygame
      
    2. Zapisz kod: Skopiuj powyższy kod i zapisz go jako plik Python, np. snake.py.
    3. Uruchom grę: Otwórz terminal lub wiersz poleceń, przejdź do folderu, w którym zapisałeś plik, i uruchom go:
      python snake.py
      

    Opis działania:

    • Inicjalizacja: Kod inicjalizuje Pygame, ustawia rozmiar ekranu, definiuje kolory i czcionki.
    • Funkcje pomocnicze:
      • wyswietl_wynik(): Wyświetla aktualny wynik gry.
      • rysuj_weza(): Rysuje węża na ekranie na podstawie listy segmentów.
      • wiadomosc(): Wyświetla wiadomość na ekranie (np. komunikat przegranej).
    • petla_gry(): Główna pętla gry, która odpowiada za:
      • Ustawianie początkowych wartości (pozycja węża, długość, pozycja jedzenia).
      • Obsługę zdarzeń (klawisze strzałek do sterowania wężem, zamknięcie okna).
      • Aktualizację pozycji węża na podstawie wciśniętych klawiszy.
      • Sprawdzanie kolizji (z krawędzią ekranu lub z samym sobą).
      • Rysowanie węża i jedzenia na ekranie.
      • Aktualizację wyniku.
      • Sprawdzanie, czy wąż zjadł jedzenie (i wydłużanie go).
      • Kontrolowanie prędkości gry.
    • Uruchomienie: Kod tworzy obiekt zegara (clock) i uruchamia główną pętlę gry (petla_gry()).

    Sterowanie:

    • Strzałki (Lewo, Prawo, Góra, Dół): Sterowanie wężem.
    • Q: Wyjście z gry po przegranej.
    • C: Rozpoczęcie nowej gry po przegranej.

    Możliwe ulepszenia:

    • Grafika: Zamiast prostokątów możesz użyć grafik dla węża i jedzenia.
    • Dźwięki: Dodaj dźwięki, np. gdy wąż zjada jedzenie.
    • Trudność: Zwiększaj prędkość gry lub zmniejszaj rozmiar węża wraz ze wzrostem wyniku.
    • Menu: Dodaj menu początkowe i menu po przegranej z opcjami.
    • Zapisywanie wyniku: Zapisuj najlepszy wynik do pliku.
    • AI: Zaimplementuj sztuczną inteligencję, aby wąż grał sam.

    Mam nadzieję, że to pomoże! Daj znać, jeśli masz jakieś pytania.

  3. User

    wygeneruj kod na prostą grę snake, kod ma być w html

  4. Gemini Assistant

    Jasne, oto prosty kod gry Snake w HTML, CSS i JavaScript (bez użycia bibliotek zewnętrznych):

    <!DOCTYPE html>
    <html>
    <head>
        <title>Snake</title>
        <style>
            body {
                display: flex;
                justify-content: center;
                align-items: center;
                height: 100vh;
                margin: 0;
                background-color: #222;
                font-family: sans-serif;
                color: #fff;
            }
    
            #gameCanvas {
                background-color: #000;
            }
        </style>
    </head>
    <body>
        <canvas id="gameCanvas" width="400" height="400"></canvas>
    
        <script>
            const canvas = document.getElementById("gameCanvas");
            const ctx = canvas.getContext("2d");
    
            const rozmiar_bloku = 20;
            const szerokosc_bloku = canvas.width / rozmiar_bloku;
            const wysokosc_bloku = canvas.height / rozmiar_bloku;
    
            let waz = [{ x: 10, y: 10 }];
            let jedzenie = { x: 5, y: 5 };
            let kierunek = "right";
            let wynik = 0;
    
            function generuj_jedzenie() {
                jedzenie = {
                    x: Math.floor(Math.random() * szerokosc_bloku),
                    y: Math.floor(Math.random() * wysokosc_bloku)
                };
                // Sprawdź, czy jedzenie nie pojawiło się na wężu
                for (let i = 0; i < waz.length; i++) {
                    if (waz[i].x === jedzenie.x && waz[i].y === jedzenie.y) {
                        generuj_jedzenie();
                        return;
                    }
                }
            }
    
            function rysuj_bloku(x, y, kolor) {
                ctx.fillStyle = kolor;
                ctx.fillRect(x * rozmiar_bloku, y * rozmiar_bloku, rozmiar_bloku, rozmiar_bloku);
            }
    
            function rysuj_weza() {
                for (let i = 0; i < waz.length; i++) {
                    rysuj_bloku(waz[i].x, waz[i].y, (i === 0) ? "#0f0" : "#0a0"); // Jaśniejszy zielony dla głowy
                }
            }
    
            function rysuj_jedzenie() {
                rysuj_bloku(jedzenie.x, jedzenie.y, "red");
            }
    
            function aktualizuj_gre() {
                let glowa_x = waz[0].x;
                let glowa_y = waz[0].y;
    
                if (kierunek === "right") glowa_x++;
                if (kierunek === "left") glowa_x--;
                if (kierunek === "up") glowa_y--;
                if (kierunek === "down") glowa_y++;
    
                if (glowa_x < 0 || glowa_x >= szerokosc_bloku || glowa_y < 0 || glowa_y >= wysokosc_bloku || kolizja_z_soba(glowa_x, glowa_y)) {
                    koniec_gry();
                    return;
                }
    
                if (glowa_x === jedzenie.x && glowa_y === jedzenie.y) {
                    wynik++;
                    generuj_jedzenie();
                } else {
                    waz.pop(); // Usuń ostatni element, jeśli nie zjedliśmy jedzenia
                }
    
                waz.unshift({ x: glowa_x, y: glowa_y }); // Dodaj nową głowę na początek
    
                ctx.clearRect(0, 0, canvas.width, canvas.height); // Wyczyść ekran
                rysuj_weza();
                rysuj_jedzenie();
                wyswietl_wynik();
            }
    
            function kolizja_z_soba(x, y) {
                for (let i = 1; i < waz.length; i++) {
                    if (x === waz[i].x && y === waz[i].y) {
                        return true;
                    }
                }
                return false;
            }
    
            function wyswietl_wynik() {
                ctx.fillStyle = "#fff";
                ctx.font = "16px sans-serif";
                ctx.fillText("Wynik: " + wynik, 10, 20);
            }
    
            function koniec_gry() {
                clearInterval(interwal_gry);
                alert("Koniec gry! Twój wynik: " + wynik);
            }
    
            document.addEventListener("keydown", (event) => {
                if (event.key === "ArrowLeft" && kierunek !== "right") kierunek = "left";
                if (event.key === "ArrowRight" && kierunek !== "left") kierunek = "right";
                if (event.key === "ArrowUp" && kierunek !== "down") kierunek = "up";
                if (event.key === "ArrowDown" && kierunek !== "up") kierunek = "down";
            });
    
            generuj_jedzenie();
            let interwal_gry = setInterval(aktualizuj_gre, 100); // Szybkość gry
        </script>
    </body>
    </html>
    

    Jak to działa:

    1. HTML (<canvas>): Tworzy element canvas, na którym rysowana jest gra.
    2. CSS (<style>): Dodaje podstawowe style, takie jak kolor tła, wyśrodkowanie i czcionkę.
    3. JavaScript:
      • Pobiera elementy: Pobiera element canvas i tworzy kontekst rysowania 2D (ctx).
      • Ustawienia: Definiuje rozmiar bloku (kwadratu), szerokość i wysokość planszy w blokach.
      • Wąż i jedzenie: Inicjalizuje węża jako tablicę współrzędnych, a jedzenie jako obiekt z współrzędnymi.
      • Kierunek: Ustawia początkowy kierunek węża.
      • Funkcje:
        • generuj_jedzenie(): Losowo generuje współrzędne jedzenia, upewniając się, że nie pojawia się na wężu.
        • rysuj_bloku(): Rysuje pojedynczy kwadrat na planszy.
        • rysuj_weza(): Rysuje węża, iterując po tablicy jego segmentów.
        • rysuj_jedzenie(): Rysuje jedzenie.
        • aktualizuj_gre():
          • Aktualizuje pozycję głowy węża na podstawie kierunku.
          • Sprawdza kolizje (ściana, własne ciało).
          • Jeśli wąż zjadł jedzenie:
            • Zwiększa wynik.
            • Generuje nowe jedzenie.
          • Jeśli nie zjadł jedzenia:
            • Usuwa ostatni element węża (ogon), aby utrzymać jego długość.
          • Dodaje nową głowę węża na początek tablicy.
          • Czyści planszę i rysuje węża, jedzenie i wynik.
        • kolizja_z_soba(): Sprawdza, czy głowa węża koliduje z którymkolwiek innym segmentem jego ciała.
        • wyswietl_wynik(): Wyświetla aktualny wynik na planszy.
        • koniec_gry(): Zatrzymuje grę i wyświetla alert z wynikiem.
      • Obsługa klawiszy: Dodaje nasłuchiwanie zdarzeń keydown, aby zmieniać kierunek węża za pomocą klawiszy strzałek.
      • Uruchomienie:
        • Generuje pierwsze jedzenie.
        • Ustawia interwał (setInterval) wywołujący aktualizuj_gre() co określony czas (kontroluje szybkość gry).

    Jak uruchomić:

    1. Skopiuj cały kod do pliku HTML (np. snake.html).
    2. Otwórz ten plik w przeglądarce internetowej.

    Ulepszenia:

    • Bardziej zaawansowany styl: Użyj CSS, aby uzyskać lepszy wygląd gry (np. tło, obramowanie, styl węża i jedzenia).
    • Dźwięki: Dodaj efekty dźwiękowe, gdy wąż zjada jedzenie lub gdy gra się kończy.
    • Ekran powitalny i ekran końca gry: Zamiast alertów, użyj elementów HTML, aby wyświetlać komunikaty.
    • Więcej poziomów trudności: Zmieniaj szybkość gry.
    • Touch control: Dodaj kontrolę dotykową dla urządzeń mobilnych.

    Ten kod zapewnia prostą, działającą wersję gry Snake w HTML, CSS i JavaScript. Możesz ją rozbudowywać i dostosowywać według własnych upodobań.

  5. User

    wygeneruj kod na prostą grę snake, kod ma być w java

  6. Gemini Assistant

    Oczywiście, oto prosty kod gry Snake w Javie z użyciem Swing (do grafiki):

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    import java.util.Random;
    
    public class SnakeGame extends JPanel implements ActionListener {
    
        private static final int SZEROKOSC = 600;
        private static final int WYSOKOSC = 600;
        private static final int ROZMIAR_BLOKU = 20;
        private static final int ILOSC_BLOKOW = SZEROKOSC / ROZMIAR_BLOKU;
        private static final int OPÓŹNIENIE = 100; // MiliSekundy
        private final int[] x = new int[ILOSC_BLOKOW * ILOSC_BLOKOW];
        private final int[] y = new int[ILOSC_BLOKOW * ILOSC_BLOKOW];
        private int dlugoscWeza = 6;
        private int jedzenieX;
        private int jedzenieY;
        private char kierunek = 'R'; // R = Prawo, L = Lewo, U = Góra, D = Dół
        private boolean dziala = false;
        private Timer timer;
        private final Random random;
    
        public SnakeGame() {
            random = new Random();
            setPreferredSize(new Dimension(SZEROKOSC, WYSOKOSC));
            setBackground(Color.BLACK);
            setFocusable(true);
            addKeyListener(new MyKeyAdapter());
            startGame();
        }
    
        public void startGame() {
            noweJedzenie();
            dziala = true;
            timer = new Timer(OPÓŹNIENIE, this);
            timer.start();
        }
    
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            draw(g);
        }
    
        public void draw(Graphics g) {
            if (dziala) {
                // Rysowanie siatki (opcjonalne)
                /*for (int i = 0; i < ILOSC_BLOKOW; i++) {
                    g.drawLine(i * ROZMIAR_BLOKU, 0, i * ROZMIAR_BLOKU, WYSOKOSC);
                    g.drawLine(0, i * ROZMIAR_BLOKU, SZEROKOSC, i * ROZMIAR_BLOKU);
                }*/
    
                g.setColor(Color.RED);
                g.fillOval(jedzenieX, jedzenieY, ROZMIAR_BLOKU, ROZMIAR_BLOKU);
    
                for (int i = 0; i < dlugoscWeza; i++) {
                    if (i == 0) {
                        g.setColor(Color.GREEN); // Głowa węża
                    } else {
                        g.setColor(new Color(45, 180, 0)); // Ciało węża
                        // Można dodać losowy kolor dla ciała
                        //g.setColor(new Color(random.nextInt(255),random.nextInt(255),random.nextInt(255)));
                    }
                    g.fillRect(x[i], y[i], ROZMIAR_BLOKU, ROZMIAR_BLOKU);
                }
    
                g.setColor(Color.WHITE);
                g.setFont(new Font("Ink Free", Font.BOLD, 20));
                FontMetrics metrics = getFontMetrics(g.getFont());
                g.drawString("Wynik: " + (dlugoscWeza - 6), (SZEROKOSC - metrics.stringWidth("Wynik: " + (dlugoscWeza - 6))) / 2, g.getFont().getSize());
            } else {
                gameOver(g);
            }
        }
    
        public void noweJedzenie() {
            jedzenieX = random.nextInt(ILOSC_BLOKOW) * ROZMIAR_BLOKU;
            jedzenieY = random.nextInt(ILOSC_BLOKOW) * ROZMIAR_BLOKU;
        }
    
        public void move() {
            for (int i = dlugoscWeza; i > 0; i--) {
                x[i] = x[i - 1];
                y[i] = y[i - 1];
            }
    
            switch (kierunek) {
                case 'U':
                    y[0] = y[0] - ROZMIAR_BLOKU;
                    break;
                case 'D':
                    y[0] = y[0] + ROZMIAR_BLOKU;
                    break;
                case 'L':
                    x[0] = x[0] - ROZMIAR_BLOKU;
                    break;
                case 'R':
                    x[0] = x[0] + ROZMIAR_BLOKU;
                    break;
            }
        }
    
        public void checkJedzenie() {
            if ((x[0] == jedzenieX) && (y[0] == jedzenieY)) {
                dlugoscWeza++;
                noweJedzenie();
            }
        }
    
        public void checkKolizje() {
            // Sprawdza czy głowa zderza się z ciałem
            for (int i = dlugoscWeza; i > 0; i--) {
                if ((x[0] == x[i]) && (y[0] == y[i])) {
                    dziala = false;
                    break;
                }
            }
            // Sprawdź, czy głowa dotyka lewej granicy
            if (x[0] < 0) {
                dziala = false;
            }
            // Sprawdź, czy głowa dotyka prawej granicy
            if (x[0] >= SZEROKOSC) {
                dziala = false;
            }
            // Sprawdź, czy głowa dotyka górnej granicy
            if (y[0] < 0) {
                dziala = false;
            }
            // Sprawdź, czy głowa dotyka dolnej granicy
            if (y[0] >= WYSOKOSC) {
                dziala = false;
            }
    
            if (!dziala) {
                timer.stop();
            }
        }
    
        public void gameOver(Graphics g) {
            // Wynik
            g.setColor(Color.WHITE);
            g.setFont(new Font("Ink Free", Font.BOLD, 40));
            FontMetrics metrics1 = getFontMetrics(g.getFont());
            g.drawString("Wynik: " + (dlugoscWeza - 6), (SZEROKOSC - metrics1.stringWidth("Wynik: " + (dlugoscWeza - 6))) / 2, g.getFont().getSize());
    
            // Game Over text
            g.setColor(Color.RED);
            g.setFont(new Font("Ink Free", Font.BOLD, 75));
            FontMetrics metrics2 = getFontMetrics(g.getFont());
            g.drawString("Game Over", (SZEROKOSC - metrics2.stringWidth("Game Over")) / 2, WYSOKOSC / 2);
        }
    
        @Override
        public void actionPerformed(ActionEvent e) {
            if (dziala) {
                move();
                checkJedzenie();
                checkKolizje();
            }
            repaint();
        }
    
        public class MyKeyAdapter extends KeyAdapter {
            @Override
            public void keyPressed(KeyEvent e) {
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_LEFT:
                        if (kierunek != 'R') {
                            kierunek = 'L';
                        }
                        break;
                    case KeyEvent.VK_RIGHT:
                        if (kierunek != 'L') {
                            kierunek = 'R';
                        }
                        break;
                    case KeyEvent.VK_UP:
                        if (kierunek != 'D') {
                            kierunek = 'U';
                        }
                        break;
                    case KeyEvent.VK_DOWN:
                        if (kierunek != 'U') {
                            kierunek = 'D';
                        }
                        break;
                }
            }
        }
    
        public static void main(String[] args) {
            JFrame frame = new JFrame("Snake Game");
            SnakeGame game = new SnakeGame();
            frame.add(game);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setResizable(false);
            frame.pack();
            frame.setLocationRelativeTo(null); // Wycentruj okno
            frame.setVisible(true);
        }
    }
    

    Jak to działa:

    1. Importy: Importuje potrzebne klasy z pakietów javax.swing i java.awt.

    2. Klasa SnakeGame:

      • Rozszerza JPanel (do rysowania) i implementuje ActionListener (do obsługi timera).
      • Stałe: Definiuje stałe takie jak szerokość, wysokość, rozmiar bloku, opóźnienie timera.
      • Pola:
        • x, y: Tablice przechowujące współrzędne każdego segmentu węża.
        • dlugoscWeza: Aktualna długość węża.
        • jedzenieX, jedzenieY: Współrzędne jedzenia.
        • kierunek: Aktualny kierunek ruchu węża ('R', 'L', 'U', 'D').
        • dziala: Flaga, która mówi, czy gra trwa.
        • timer: Obiekt Timer do animacji gry.
        • random: Generator liczb losowych.
      • Konstruktor:
        • Ustawia preferowany rozmiar, kolor tła, włącza focus (potrzebny do obsługi klawiszy) i dodaje KeyListener.
        • Wywołuje startGame().
      • startGame():
        • Generuje nowe jedzenie.
        • Ustawia dziala na true.
        • Tworzy i uruchamia Timer.
      • paintComponent():
        • Rysuje wszystko na ekranie (węża, jedzenie, wynik) - wywoływane automatycznie przez Swing.
        • Wywołuje draw(), aby oddzielić logikę rysowania.
      • draw():
        • Rysuje jedzenie jako czerwone kółko.
        • Rysuje węża, używając zielonego dla głowy i ciemniejszego zielonego dla ciała.
        • Rysuje wynik na górze ekranu.
        • Jeśli gra się skończyła, wywołuje gameOver().
      • noweJedzenie():
        • Losowo generuje współrzędne dla jedzenia.
      • move():
        • Przesuwa wszystkie segmenty węża o jedną pozycję do przodu.
        • Aktualizuje pozycję głowy węża w zależności od kierunku.
      • checkJedzenie():
        • Sprawdza, czy głowa węża zjadła jedzenie.
        • Jeśli tak, wydłuża węża i generuje nowe jedzenie.
      • checkKolizje():
        • Sprawdza, czy głowa węża zderzyła się z ciałem lub z krawędzią ekranu.
        • Jeśli tak, ustawia dziala na false i zatrzymuje Timer.
      • gameOver():
        • Rysuje komunikat "Game Over" na środku ekranu.
      • actionPerformed():
        • Metoda wywoływana przez Timer co określony interwał.
        • Przesuwa węża, sprawdza jedzenie, sprawdza kolizje i odświeża ekran.
      • MyKeyAdapter:
        • Klasa wewnętrzna, która implementuje KeyListener.
        • Obsługuje wciśnięcia klawiszy strzałek i zmienia kierunek węża.
    3. main():

      • Tworzy okno (JFrame).
      • Tworzy obiekt SnakeGame i dodaje go do okna.
      • Ustawia domyślną operację zamknięcia okna, wyłącza zmianę rozmiaru, dopasowuje rozmiar okna do zawartości i pokazuje okno.

    Jak uruchomić:

    1. Zapisz kod: Skopiuj powyższy kod i zapisz go jako plik SnakeGame.java.
    2. Skompiluj: Otwórz terminal lub wiersz poleceń i skompiluj kod:
      javac SnakeGame.java
      
    3. Uruchom: Uruchom skompilowany program:
      java SnakeGame
      

    Sterowanie:

    • Strzałki (Lewo, Prawo, Góra, Dół): Sterowanie wężem.

    Możliwe ulepszenia:

    • Grafika: Użyj lepszych grafik dla węża i jedzenia.
    • Dźwięki: Dodaj dźwięki, np. gdy wąż zjada jedzenie.
    • Trudność: Zmieniaj prędkość gry lub rozmiar węża.
    • Menu: Dodaj menu początkowe i menu po przegranej.
    • Zapisywanie wyniku: Zapisuj najlepszy wynik do pliku.
    • Power-upy: Dodaj różne bonusy, które pojawiają się na planszy.

    Mam nadzieję, że to pomoże! Daj znać, jeśli masz jakieś pytania.

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