Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

czy mozesz stworzyc gre wezyk

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-5-sonnet-20241022’s answer.
  1. User

    czy mozesz stworzyc gre wezyk

  2. Meta Assistant

    Oczywiście, mogę pomóc Ci stworzyć prostą grę "Wąż" (Snake) w Pythonie przy użyciu biblioteki Pygame. Gra będzie miała następujące funkcje:

    1. Wąż porusza się po ekranie.
    2. Gracz steruje wężem za pomocą strzałek.
    3. Wąż zjada jedzenie (np. czerwone kropki), które pojawia się losowo na ekranie.
    4. Za każdym zjadanym jedzeniem wąż rośnie.
    5. Gra kończy się, gdy wąż uderzy w ścianę lub w siebie samego.

    Zanim zaczniemy:

    Upewnij się, że masz zainstalowany Python oraz bibliotekę Pygame. Jeśli nie masz Pygame, możesz ją zainstalować wpisując w terminalu/konsoli:

    pip install pygame
    

    Teraz kod gry:

    import pygame
    import sys
    import random
    import time
    
    # Inicjacja Pygame
    pygame.init()
    
    # Ustawienia ekranu
    szerokosc_ekranu = 800
    wysokosc_ekranu = 600
    ekran = pygame.display.set_mode((szerokosc_ekranu, wysokosc_ekranu))
    pygame.display.set_caption('Gra Wąż')
    
    # Kolory
    bialy = (255, 255, 255)
    czarny = (0, 0, 0)
    czerwony = (255, 0, 0)
    zielony = (0, 255, 0)
    
    # Rozmiar węża i jedzenia
    rozmiar_bloku = 20
    
    # Prędkość węża
    fps = 10
    
    # Klasa węża
    class Wezyk:
        def __init__(self):
            self.x = szerokosc_ekranu / 2
            self.y = wysokosc_ekranu / 2
            self.kierunek_x = 0
            self.kierunek_y = 0
            self.czesci = [(self.x, self.y)]
    
        def ruch(self):
            nowa_glowa = (self.x + self.kierunek_x * rozmiar_bloku, 
                          self.y + self.kierunek_y * rozmiar_bloku)
            self.czesci.insert(0, nowa_glowa)
            self.x, self.y = nowa_glowa
    
        def zmien_kierunek(self, kierunek):
            if kierunek == 'prawo' and self.kierunek_x != -1:
                self.kierunek_x = 1
                self.kierunek_y = 0
            elif kierunek == 'lewo' and self.kierunek_x != 1:
                self.kierunek_x = -1
                self.kierunek_y = 0
            elif kierunek == 'gora' and self.kierunek_y != 1:
                self.kierunek_x = 0
                self.kierunek_y = -1
            elif kierunek == 'dol' and self.kierunek_y != -1:
                self.kierunek_x = 0
                self.kierunek_y = 1
    
    # Funkcja do rysowania węża
    def rysuj_weza(ekran, wezyk):
        for x, y in wezyk.czesci:
            pygame.draw.rect(ekran, zielony, (x, y, rozmiar_bloku, rozmiar_bloku))
    
    # Funkcja główna gry
    def gra():
        zegar = pygame.time.Clock()
        wezyk = Wezyk()
        wezyk.zmien_kierunek('prawo')  # Startowy kierunek
        
        jedzenie_x = round(random.randint(0, szerokosc_ekranu - rozmiar_bloku) / rozmiar_bloku) * rozmiar_bloku
        jedzenie_y = round(random.randint(0, wysokosc_ekranu - rozmiar_bloku) / rozmiar_bloku) * rozmiar_bloku
        
        wynik = 0
        
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        wezyk.zmien_kierunek('lewo')
                    elif event.key == pygame.K_RIGHT:
                        wezyk.zmien_kierunek('prawo')
                    elif event.key == pygame.K_UP:
                        wezyk.zmien_kierunek('gora')
                    elif event.key == pygame.K_DOWN:
                        wezyk.zmien_kierunek('dol')
            
            wezyk.ruch()
            
            # Sprawdzenie kolizji z jedzeniem
            if wezyk.x == jedzenie_x and wezyk.y == jedzenie_y:
                wynik += 1
                jedzenie_x = round(random.randint(0, szerokosc_ekranu - rozmiar_bloku) / rozmiar_bloku) * rozmiar_bloku
                jedzenie_y = round(random.randint(0, wysokosc_ekranu - rozmiar_bloku) / rozmiar_bloku) * rozmiar_bloku
            else:
                wezyk.czesci.pop()  # Usuwanie ostatniego elementu węża, jeśli nie zjadł jedzenia
            
            # Sprawdzenie kolizji ze ścianami lub samym sobą
            if (wezyk.x < 0 or wezyk.x >= szerokosc_ekranu or 
                wezyk.y < 0 or wezyk.y >= wysokosc_ekranu or 
                (wezyk.x, wezyk.y) in wezyk.czesci[1:]):
                print(f"Koniec gry! Twój wynik: {wynik}")
                time.sleep(2)
                pygame.quit()
                sys.exit()
            
            # Rysowanie wszystkiego
            ekran.fill(czarny)
            rysuj_weza(ekran, wezyk)
            pygame.draw.rect(ekran, czerwony, (jedzenie_x, jedzenie_y, rozmiar_bloku, rozmiar_bloku))
            
            # Wyświetlanie wyniku
            font = pygame.font.Font(None, 36)
            tekst = font.render(f"Wynik: {wynik}", True, bialy)
            ekran.blit(tekst, (10, 10))
            
            pygame.display.update()
            zegar.tick(fps)
    
    if __name__ == "__main__":
        gra()
    

    Jak grać?

    1. Uruchom powyższy kod w swoim środowisku Pythona.
    2. Użyj strzałek (←, →, ↑, ↓), aby sterować wężem.
    3. Zjadaj czerwone kropki (jedzenie), aby rosnąć i zdobywać punkty.
    4. Unikaj uderzania w ściany oraz ogon węża.

    Co możesz poprawić lub dodać?

    • Większa responsywność sterowania: Dostosuj fps na początku kodu, aby zwiększyć lub zmniejszyć szybkość gry.
    • Lepsze efekty wizualne: Dodaj różne kolory dla węża, jedzenia lub nawet tła.
    • Dźwięki: Dodaj dźwięki przy zjadaniu jedzenia lub przy przegranej (użyj pygame.mixer).
    • Menu startowe i restart: Stwórz prosty ekran startowy z opcją "Nowa gra" i "Wyjdź".
    • Zapisywanie najlepszego wyniku: Do pliku lub zmiennej, tak aby po restarcie gry móc zobaczyć swój rekord.

    Miłej zabawy z grą "Wąż"! Jeśli masz pytania lub chcesz wprowadzić jakieś modyfikacje, pytaj śmiało!

  3. User

    czy mozesz ja stworzyc w html

  4. Meta Assistant

    Oczywiście! Poniżej znajdziesz wersję gry "Wąż" (Snake) stworzoną przy użyciu HTML, CSS oraz JavaScript. Gra działa w przeglądarce internetowej i ma wszystkie podstawowe funkcje:

    1. Wąż porusza się po planszy.
    2. Sterowanie za pomocą strzałek (↑, ↓, ←, →).
    3. Wąż zjada czerwone kropki (jedzenie), które pojawiają się losowo.
    4. Wąż rośnie po każdym zjedzeniu jedzenia.
    5. Gra kończy się przy kolizji ze ścianą lub samym sobą.
    6. Wynik jest wyświetlany na bieżąco.

    Kod gry:

    HTML (index.html)

    <!DOCTYPE html>
    <html lang="pl">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Gra Wąż (Snake)</title>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <canvas id="plansza"></canvas>
        <div id="wynik">Wynik: 0</div>
        <div id="koniec-gry" style="display: none;">
            <h2>Koniec gry!</h2>
            <p id="wynik-koniec"></p>
            <button id="restart">Zagraj ponownie</button>
        </div>
    
        <script src="script.js"></script>
    </body>
    </html>
    

    CSS (style.css)

    body {
        margin: 0;
        background-color: #f0f0f0;
        display: flex;
        justify-content: center;
        align-items: center;
        height: 100vh;
        flex-direction: column;
        font-family: Arial, sans-serif;
    }
    
    #plansza {
        border: 2px solid black;
        background-color: #000;
    }
    
    #wynik {
        font-size: 24px;
        margin-top: 10px;
        font-weight: bold;
    }
    
    #koniec-gry {
        text-align: center;
        margin-top: 20px;
    }
    
    #koniec-gry h2 {
        color: red;
    }
    
    #restart {
        padding: 10px 20px;
        font-size: 18px;
        cursor: pointer;
    }
    

    JavaScript (script.js)

    const canvas = document.getElementById('plansza');
    const ctx = canvas.getContext('2d');
    const wynikElement = document.getElementById('wynik');
    const koniecGryDiv = document.getElementById('koniec-gry');
    const wynikKoniecElement = document.getElementById('wynik-koniec');
    const restartButton = document.getElementById('restart');
    
    // Ustawienia gry
    const rozmiarPlanszy = 400;
    canvas.width = rozmiarPlanszy;
    canvas.height = rozmiarPlanszy;
    const rozmiarBloku = 20;
    let fps = 10;
    
    // Kolory
    const kolorWeza = 'green';
    const kolorJedzenia = 'red';
    const kolorTla = 'black';
    
    // Zmienne gry
    let wez = [{ x: rozmiarPlanszy / 2, y: rozmiarPlanszy / 2 }];
    let kierunek = { x: 1, y: 0 };
    let jedzenie = { x: 0, y: 0 };
    let wynik = 0;
    let graAktywna = true;
    
    // Funkcja generująca jedzenie w losowym miejscu
    function generujJedzenie() {
        jedzenie.x = Math.floor(Math.random() * (rozmiarPlanszy / rozmiarBloku)) * rozmiarBloku;
        jedzenie.y = Math.floor(Math.random() * (rozmiarPlanszy / rozmiarBloku)) * rozmiarBloku;
    
        // Upewnij się, że jedzenie nie pojawi się na wężu
        if (wez.some(czesc => czesc.x === jedzenie.x && czesc.y === jedzenie.y)) {
            generujJedzenie();
        }
    }
    
    // Rysowanie planszy
    function rysujPlansze() {
        ctx.fillStyle = kolorTla;
        ctx.fillRect(0, 0, rozmiarPlanszy, rozmiarPlanszy);
    
        // Rysuj węża
        wez.forEach(czesc => {
            ctx.fillStyle = kolorWeza;
            ctx.fillRect(czesc.x, czesc.y, rozmiarBloku, rozmiarBloku);
        });
    
        // Rysuj jedzenie
        ctx.fillStyle = kolorJedzenia;
        ctx.fillRect(jedzenie.x, jedzenie.y, rozmiarBloku, rozmiarBloku);
    }
    
    // Aktualizacja gry
    function aktualizujGre() {
        if (!graAktywna) return;
    
        // Nowa pozycja głowy węża
        const nowaGlowa = {
            x: wez[0].x + kierunek.x * rozmiarBloku,
            y: wez[0].y + kierunek.y * rozmiarBloku
        };
    
        // Sprawdź kolizję ze ścianami
        if (nowaGlowa.x < 0 || nowaGlowa.x >= rozmiarPlanszy || nowaGlowa.y < 0 || nowaGlowa.y >= rozmiarPlanszy) {
            zakonczGre();
            return;
        }
    
        // Sprawdź kolizję z własnym ogonem
        if (wez.some((czesc, index) => index > 0 && czesc.x === nowaGlowa.x && czesc.y === nowaGlowa.y)) {
            zakonczGre();
            return;
        }
    
        // Dodaj nową głowę
        wez.unshift(nowaGlowa);
    
        // Sprawdź czy wąż zjadł jedzenie
        if (nowaGlowa.x === jedzenie.x && nowaGlowa.y === jedzenie.y) {
            wynik++;
            wynikElement.textContent = `Wynik: ${wynik}`;
            generujJedzenie();
        } else {
            wez.pop(); // Usuń ostatni element ogona
        }
    
        rysujPlansze();
    }
    
    // Obsługa klawiatury
    document.addEventListener('keydown', (e) => {
        if (!graAktywna) return;
    
        switch (e.key) {
            case 'ArrowUp':
                if (kierunek.y !== 1) { kierunek = { x: 0, y: -1 }; }
                break;
            case 'ArrowDown':
                if (kierunek.y !== -1) { kierunek = { x: 0, y: 1 }; }
                break;
            case 'ArrowLeft':
                if (kierunek.x !== 1) { kierunek = { x: -1, y: 0 }; }
                break;
            case 'ArrowRight':
                if (kierunek.x !== -1) { kierunek = { x: 1, y: 0 }; }
                break;
        }
    });
    
    // Zakończenie gry
    function zakonczGre() {
        graAktywna = false;
        wynikKoniecElement.textContent = `Twój wynik: ${wynik}`;
        koniecGryDiv.style.display = 'block';
    }
    
    // Restart gry
    restartButton.addEventListener('click', () => {
        wez = [{ x: rozmiarPlanszy / 2, y: rozmiarPlanszy / 2 }];
        kierunek = { x: 1, y: 0 };
        wynik = 0;
        wynikElement.textContent = `Wynik: ${wynik}`;
        generujJedzenie();
        graAktywna = true;
        koniecGryDiv.style.display = 'none';
        rysujPlansze();
    });
    
    // Główna pętla gry
    setInterval(() => {
        aktualizujGre();
    }, 1000 / fps);
    
    // Inicjacja gry
    generujJedzenie();
    rysujPlansze();
    

    Jak uruchomić grę?

    1. Utwórz trzy pliki:
      • index.html (wklej kod HTML)
      • style.css (wklej kod CSS)
      • script.js (wklej kod JavaScript)
    2. Umieść wszystkie pliki w jednym folderze.
    3. Otwórz plik index.html w przeglądarce (np. Chrome, Firefox).
    4. Grać możesz od razu za pomocą strzałek!

    Co się dzieje w grze?

    • Klawisze:
      • ↑ – w górę
      • ↓ – w dół
      • ← – w lewo
      • → – w prawo
    • Zasady:
      • Zjedz czerwoną kropkę, aby zdobyć punkt i wydłużyć węża.
      • Nie uderz w ścianę ani w ogon węża – inaczej przegrywasz!
    • Po przegranej:
      • Pojawi się komunikat z Twoim wynikiem.
      • Kliknij "Zagraj ponownie", aby zacząć od nowa.

    Możliwości rozbudowy gry:

    1. Dodaj dźwięki:
      • Użyj new Audio('sound.mp3').play() przy zjedzeniu jedzenia lub przegranej.
    2. Lepsze efekty wizualne:
      • Zmień kolory węża, jedzenia lub tła w style.css i script.js.
    3. Zapisywanie najlepszego wyniku:
      • Dodaj localStorage, aby zapisywać rekord w przeglądarce.
      • Przykład:
        localStorage.setItem('najlepszy_wynik', Math.max(wynik, localStorage.getItem('najlepszy_wynik') || 0));
        
    4. Trudniejsze poziomy:
      • Zwiększaj fps co 5 punktów, aby gra przyspieszała.
    5. Ściany przeszkody:
      • Dodaj dodatkowe bloki na planszy, których wąż nie może przekroczyć.

    Miłej zabawy! Jeśli potrzebujesz pomocy lub chcesz wprowadzić nowe funkcje – pytaj! 😊

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