wygeneruj kod na prostą grę snake
- User
wygeneruj kod na prostą grę snake
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ć:
- Zainstaluj Pygame:
pip install pygame - Zapisz kod: Skopiuj powyższy kod i zapisz go jako plik Python, np.
snake.py. - 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.
- Zainstaluj Pygame:
- User
wygeneruj kod na prostą grę snake, kod ma być w html
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:
- HTML (
<canvas>): Tworzy elementcanvas, na którym rysowana jest gra. - CSS (
<style>): Dodaje podstawowe style, takie jak kolor tła, wyśrodkowanie i czcionkę. - JavaScript:
- Pobiera elementy: Pobiera element
canvasi 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ącyaktualizuj_gre()co określony czas (kontroluje szybkość gry).
- Pobiera elementy: Pobiera element
Jak uruchomić:
- Skopiuj cały kod do pliku HTML (np.
snake.html). - 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ń.
- HTML (
- User
wygeneruj kod na prostą grę snake, kod ma być w java
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:
-
Importy: Importuje potrzebne klasy z pakietów
javax.swingijava.awt. -
Klasa
SnakeGame:- Rozszerza
JPanel(do rysowania) i implementujeActionListener(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: ObiektTimerdo 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().
- Ustawia preferowany rozmiar, kolor tła, włącza focus (potrzebny do obsługi klawiszy) i dodaje
startGame():- Generuje nowe jedzenie.
- Ustawia
dzialanatrue. - 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
dzialanafalsei zatrzymujeTimer.
gameOver():- Rysuje komunikat "Game Over" na środku ekranu.
actionPerformed():- Metoda wywoływana przez
Timerco określony interwał. - Przesuwa węża, sprawdza jedzenie, sprawdza kolizje i odświeża ekran.
- Metoda wywoływana przez
MyKeyAdapter:- Klasa wewnętrzna, która implementuje
KeyListener. - Obsługuje wciśnięcia klawiszy strzałek i zmienia kierunek węża.
- Klasa wewnętrzna, która implementuje
- Rozszerza
-
main():- Tworzy okno (
JFrame). - Tworzy obiekt
SnakeGamei dodaje go do okna. - Ustawia domyślną operację zamknięcia okna, wyłącza zmianę rozmiaru, dopasowuje rozmiar okna do zawartości i pokazuje okno.
- Tworzy okno (
Jak uruchomić:
- Zapisz kod: Skopiuj powyższy kod i zapisz go jako plik
SnakeGame.java. - Skompiluj: Otwórz terminal lub wiersz poleceń i skompiluj kod:
javac SnakeGame.java - 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.
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.