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

napisz dla mnie grę w węża

  1. User

    napisz dla mnie grę w węża

  2. Assistant

    Jasne, oto kod prostej gry w węża napisanej w Pythonie przy użyciu biblioteki Pygame.

    Czego potrzebujesz:

    1. Zainstalowany Python (wersja 3.x zalecana).
    2. Zainstalowana biblioteka Pygame. Możesz ją zainstalować za pomocą pip:
      pip install pygame
      

    Kod gry:

    import pygame
    import random
    import sys
    
    # Inicjalizacja Pygame
    pygame.init()
    
    # Ustawienia ekranu
    SZEROKOSC_EKRANU = 600
    WYSOKOSC_EKRANU = 400
    ekran = pygame.display.set_mode((SZEROKOSC_EKRANU, WYSOKOSC_EKRANU))
    pygame.display.set_caption("Gra w Węża")
    
    # Kolory (RGB)
    CZARNY = (0, 0, 0)
    BIALY = (255, 255, 255)
    ZIELONY = (0, 255, 0)
    CZERWONY = (255, 0, 0)
    
    # Ustawienia gry
    ROZMIAR_KOMORKI = 20
    PREDKOSC = 10 # Początkowa prędkość węża (klatki na sekundę)
    
    # Czcionka
    czcionka_wyniku = pygame.font.SysFont("monospace", 25)
    czcionka_koniec = pygame.font.SysFont("monospace", 50)
    
    # Funkcja do rysowania węża
    def rysuj_weza(cialo_weza):
        for segment in cialo_weza:
            pygame.draw.rect(ekran, ZIELONY, [segment[0] * ROZMIAR_KOMORKI, segment[1] * ROZMIAR_KOMORKI, ROZMIAR_KOMORKI, ROZMIAR_KOMORKI])
    
    # Funkcja do rysowania jedzenia
    def rysuj_jedzenie(pozycja_jedzenia):
         pygame.draw.rect(ekran, CZERWONY, [pozycja_jedzenia[0] * ROZMIAR_KOMORKI, pozycja_jedzenia[1] * ROZMIAR_KOMORKI, ROZMIAR_KOMORKI, ROZMIAR_KOMORKI])
    
    # Funkcja do wyświetlania wyniku
    def wyswietl_wynik(wynik):
        tekst_wyniku = czcionka_wyniku.render(f"Wynik: {wynik}", True, BIALY)
        ekran.blit(tekst_wyniku, [10, 10])
    
    # Funkcja do wyświetlania komunikatu "Koniec gry"
    def komunikat_koniec_gry(wynik):
        tekst_koniec = czcionka_koniec.render("Koniec Gry!", True, BIALY)
        tekst_wynik_koncowy = czcionka_wyniku.render(f"Twój wynik: {wynik}", True, BIALY)
        ekran.blit(tekst_koniec, [SZEROKOSC_EKRANU // 2 - tekst_koniec.get_width() // 2, WYSOKOSC_EKRANU // 3])
        ekran.blit(tekst_wynik_koncowy, [SZEROKOSC_EKRANU // 2 - tekst_wynik_koncowy.get_width() // 2, WYSOKOSC_EKRANU // 2])
        pygame.display.flip()
        # Czekaj chwilę lub na wciśnięcie klawisza przed wyjściem
        pygame.time.wait(3000) # Czekaj 3 sekundy
        # Alternatywnie:
        # czekaj = True
        # while czekaj:
        #     for event in pygame.event.get():
        #         if event.type == pygame.QUIT:
        #             pygame.quit()
        #             sys.exit()
        #         if event.type == pygame.KEYDOWN:
        #             czekaj = False
    
    
    # Główna funkcja gry
    def gra_weza():
        gra_zakonczona = False
        koniec_gry = False
    
        # Początkowa pozycja węża (lista segmentów)
        waz_cialo = [(10, 10), (9, 10), (8, 10)]
        # Początkowy kierunek (dx, dy) - (1, 0) to w prawo
        kierunek = (1, 0)
    
        # Początkowa pozycja jedzenia
        # Upewniamy się, że jedzenie nie pojawi się na wężu od razu
        while True:
            jedzenie_pozycja = (random.randrange(SZEROKOSC_EKRANU // ROZMIAR_KOMORKI),
                               random.randrange(WYSOKOSC_EKRANU // ROZMIAR_KOMORKI))
            if jedzenie_pozycja not in waz_cialo:
                break
    
        wynik = 0
        zegar = pygame.time.Clock()
    
        # Pętla gry
        while not gra_zakonczona:
    
            while koniec_gry:
                komunikat_koniec_gry(wynik)
                gra_zakonczona = True # Ustawiamy gra_zakonczona na True po wyświetleniu komunikatu
    
            # Obsługa zdarzeń (np. wciśnięcie klawisza)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    gra_zakonczona = True # Wyjście z pętli gry
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT and kierunek != (1, 0): # Nie można zawrócić
                        kierunek = (-1, 0)
                    elif event.key == pygame.K_RIGHT and kierunek != (-1, 0):
                        kierunek = (1, 0)
                    elif event.key == pygame.K_UP and kierunek != (0, 1):
                        kierunek = (0, -1)
                    elif event.key == pygame.K_DOWN and kierunek != (0, -1):
                        kierunek = (0, 1)
    
            # Obliczanie nowej pozycji głowy
            glowa_x = waz_cialo[0][0] + kierunek[0]
            glowa_y = waz_cialo[0][1] + kierunek[1]
            nowa_glowa = (glowa_x, glowa_y)
    
            # Sprawdzenie kolizji ze ścianami
            if glowa_x < 0 or glowa_x >= SZEROKOSC_EKRANU // ROZMIAR_KOMORKI or \
               glowa_y < 0 or glowa_y >= WYSOKOSC_EKRANU // ROZMIAR_KOMORKI:
                koniec_gry = True # Wąż uderzył w ścianę
    
            # Sprawdzenie kolizji z własnym ciałem (pomijamy nową głowę, która jest już w liście)
            # Nowa głowa jest już dodana na początku listy, więc sprawdzamy od drugiego elementu
            if nowa_glowa in waz_cialo[1:]:
                koniec_gry = True # Wąż uderzył w siebie
    
            # Jeśli nie ma kolizji, dodaj nową głowę
            waz_cialo.insert(0, nowa_glowa)
    
            # Sprawdzenie kolizji z jedzeniem
            if nowa_glowa == jedzenie_pozycja:
                wynik += 1
                # Wygeneruj nowe jedzenie, upewniając się, że nie jest na wężu
                while True:
                    jedzenie_pozycja = (random.randrange(SZEROKOSC_EKRANU // ROZMIAR_KOMORKI),
                                       random.randrange(WYSOKOSC_EKRANU // ROZMIAR_KOMORKI))
                    if jedzenie_pozycja not in waz_cialo:
                        break
                # Nie usuwaj ogona - wąż rośnie
            else:
                # Usuń ostatni segment (ogon) - wąż się przesuwa
                waz_cialo.pop()
    
            # Rysowanie
            ekran.fill(CZARNY) # Wypełnij tło
            rysuj_weza(waz_cialo)
            rysuj_jedzenie(jedzenie_pozycja)
            wyswietl_wynik(wynik)
    
            # Aktualizacja ekranu
            pygame.display.flip()
    
            # Kontrola prędkości gry
            zegar.tick(PREDKOSC)
    
        # Po wyjściu z pętli głównej (gra_zakonczona jest True)
        # Wyświetl ekran końca gry z ostatecznym wynikiem
        komunikat_koniec_gry(wynik)
    
        pygame.quit() # Zamknij Pygame
        sys.exit()    # Wyjdź z programu
    
    # Uruchomienie gry
    if __name__ == "__main__":
        gra_weza()
    

    Jak uruchomić grę:

    1. Zapisz powyższy kod w pliku o nazwie np. waz.py.
    2. Otwórz terminal lub wiersz poleceń.
    3. Przejdź do katalogu, w którym zapisałeś plik.
    4. Uruchom grę poleceniem:
      python waz.py
      

    Sterowanie:

    • Używaj klawiszy strzałek (Góra, Dół, Lewo, Prawo) do zmiany kierunku węża.

    Zasady:

    • Zjedz czerwony kwadrat (jedzenie), aby urosnąć i zdobyć punkt.
    • Unikaj uderzenia w ściany.
    • Unikaj uderzenia w własne ciało.
    • Uderzenie w ścianę lub ciało kończy grę.

    Baw się dobrze!

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