Skip to content
TheChatArchiveThe Chat Archive
grok-3-mini-high· xAIHugging Face LMArena Human Preference 140K

Napisz podstawową grę platformową w PyGame z tymi elementami: [KONTEKST] - Rozdzielczość…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b’s answer.
  1. User

    Napisz podstawową grę platformową w PyGame z tymi elementami: [KONTEKST]

    • Rozdzielczość 800x600
    • Gracz (zielony prostokąt) porusza się strzałkami, skok spacją
    • Platformy: 5 stałych platform + 1 ruchoma (poziomo)
    • Przeciwnik (czerwone koło) poruszający się po wzorze sinus
    • Zbierane gwiazdki (żółte) zwiększające wynik

    [WYMAGANIA]

    • Fizyka: grawitacja, kolizje z platformami
    • System punktacji i wyświetlanie HUD
    • Proste menu start/pauza
    • Dźwięki: skok, zbieranie, śmierć (użyj pygame.mixer)

    [STRUKTURA KODU]

    • Klasy: Player, Platform, Enemy, Star
    • Główna pętla gry z delta time
    • Oddzielna funkcja kolizji

    Zwróć kompletny kod w jednym pliku .py

  2. Assistant
    import pygame
    import math
    import sys
    
    # Inicjalizacja Pygame
    pygame.init()
    pygame.mixer.init()
    
    # Ustawienia ekranu
    WIDTH, HEIGHT = 800, 600
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Prosta Gra Platformowa")
    clock = pygame.time.Clock()
    FPS = 60
    
    # Kolory
    GREEN = (0, 255, 0)
    RED = (255, 0, 0)
    YELLOW = (255, 255, 0)
    WHITE = (255, 255, 255)
    BLACK = (0, 0, 0)
    
    # Dźwięki
    try:
        jump_sound = pygame.mixer.Sound('jump.wav')  # Zakładamy, że plik istnieje
        collect_sound = pygame.mixer.Sound('collect.wav')
        death_sound = pygame.mixer.Sound('death.wav')
    except pygame.error as e:
        print(f"Błąd ładowania dźwięku: {e}")
        jump_sound = None
        collect_sound = None
        death_sound = None
    
    # Klasy
    class Player(pygame.sprite.Sprite):
        def __init__(self):
            super().__init__()
            self.image = pygame.Surface((50, 50))
            self.image.fill(GREEN)
            self.rect = self.image.get_rect()
            self.rect.x = 100
            self.rect.y = 500
            self.vel_x = 0
            self.vel_y = 0
            self.on_ground = False
            self.jump_power = -15  # Siła skoku
    
        def update(self, platforms):
            # Grawitacja
            self.vel_y += 0.5  # Stała grawitacji
    
            # Ruch poziomy
            self.rect.x += self.vel_x
    
            # Kolizje poziome
            self.check_collisions(platforms)
    
            # Ruch pionowy
            self.rect.y += self.vel_y
            self.on_ground = False  # Resetuj stan na ziemi
    
            # Kolizje pionowe
            self.check_collisions(platforms)
    
        def check_collisions(self, platforms):
            for platform in platforms:
                if self.rect.colliderect(platform.rect):
                    if self.vel_y > 0 and self.rect.bottom <= platform.rect.bottom:  # Upadanie
                        self.rect.bottom = platform.rect.top
                        self.vel_y = 0
                        self.on_ground = True
                    elif self.vel_y < 0:  # Skok w górę
                        self.rect.top = platform.rect.bottom
                        self.vel_y = 0
    
        def jump(self):
            if self.on_ground:
                self.vel_y = self.jump_power
                if jump_sound:
                    jump_sound.play()
    
    class Platform(pygame.sprite.Sprite):
        def __init__(self, x, y, w, h, moving=False):
            super().__init__()
            self.image = pygame.Surface((w, h))
            self.image.fill(WHITE)
            self.rect = self.image.get_rect()
            self.rect.x = x
            self.rect.y = y
            self.moving = moving
            if moving:
                self.direction = 1  # 1 - prawo, -1 - lewo
                self.speed = 2
    
        def update(self):
            if self.moving:
                self.rect.x += self.speed * self.direction
                if self.rect.x > 700 or self.rect.x < 100:
                    self.direction *= -1
    
    class Enemy(pygame.sprite.Sprite):
        def __init__(self, x, y):
            super().__init__()
            self.image = pygame.Surface((30, 30), pygame.SRCALPHA)
            pygame.draw.circle(self.image, RED, (15, 15), 15)
            self.rect = self.image.get_rect()
            self.rect.x = x
            self.rect.y = y
            self.speed = 2
            self.angle = 0
    
        def update(self):
            self.rect.x += self.speed
            self.rect.y = 200 + 50 * math.sin(self.angle)  # Ruch sinusoidalny
            self.angle += 0.1
            if self.rect.x > WIDTH:
                self.rect.x = 0
    
    class Star(pygame.sprite.Sprite):
        def __init__(self, x, y):
            super().__init__()
            self.image = pygame.Surface((20, 20))
            self.image.fill(YELLOW)
            self.rect = self.image.get_rect()
            self.rect.x = x
            self.rect.y = y
    
    # Funkcja kolizji (oddzielna, jak wymagane)
    def handle_collisions(player, stars, enemies):
        collected = pygame.sprite.spritecollide(player, stars, True)  # Zbieranie gwiazdek
        for star in collected:
            if collect_sound:
                collect_sound.play()
            return len(collected)  # Zwraca liczbę zebranych gwiazdek
    
        if pygame.sprite.spritecollide(player, enemies, False):
            if death_sound:
                death_sound.play()
            return -1  # Śmierć gracza
        return 0  # Brak zmian
    
    # Główna funkcja gry
    def main():
        all_sprites = pygame.sprite.Group()
        platforms = pygame.sprite.Group()
        enemies = pygame.sprite.Group()
        stars = pygame.sprite.Group()
    
        # Tworzenie obiektów
        player = Player()
        all_sprites.add(player)
    
        # 5 stałych platform
        platform1 = Platform(0, 550, 800, 50)  # Podłoga
        platform2 = Platform(200, 400, 200, 20)
        platform3 = Platform(400, 300, 200, 20)
        platform4 = Platform(100, 200, 200, 20)
        platform5 = Platform(500, 100, 200, 20)
        moving_platform = Platform(300, 450, 150, 20, moving=True)
    
        platforms.add(platform1, platform2, platform3, platform4, platform5, moving_platform)
        all_sprites.add(platforms)
    
        enemy = Enemy(600, 200)
        enemies.add(enemy)
        all_sprites.add(enemy)
    
        # Gwiazki
        star1 = Star(250, 350)
        star2 = Star(450, 250)
        star3 = Star(150, 150)
        stars.add(star1, star2, star3)
        all_sprites.add(stars)
    
        score = 0
        font = pygame.font.Font(None, 36)
        in_menu = True  # Stan menu
    
        running = True
        while running:
            dt = clock.tick(FPS) / 1000.0  # Delta time
    
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                elif event.type == pygame.KEYDOWN:
                    if in_menu and event.key == pygame.K_SPACE:
                        in_menu = False  # Start gry
                    elif event.key == pygame.K_p:  # Pauza
                        in_menu = not in_menu
                    elif not in_menu:
                        if event.key == pygame.K_SPACE:
                            player.jump()
                        elif event.key == pygame.K_LEFT:
                            player.vel_x = -5
                        elif event.key == pygame.K_RIGHT:
                            player.vel_x = 5
                        elif event.key == pygame.K_UP:
                            pass  # Możliwy dodatkowy skok
                elif event.type == pygame.KEYUP:
                    if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                        player.vel_x = 0
    
            if not in_menu:
                all_sprites.update(platforms)  # Aktualizuj z platformami dla kolizji
    
                points = handle_collisions(player, stars, enemies)
                if points > 0:
                    score += points
                elif points == -1:
                    score = 0  # Reset po śmierci
                    player.rect.x = 100
                    player.rect.y = 500
                    player.vel_y = 0
    
            screen.fill(BLACK)
    
            if in_menu:
                text = font.render("Naciśnij SPACE aby zacząć", True, WHITE)
                screen.blit(text, (WIDTH//2 - 150, HEIGHT//2))
            else:
                all_sprites.draw(screen)
                score_text = font.render(f"Score: {score}", True, WHITE)
                screen.blit(score_text, (10, 10))  # HUD
    
            pygame.display.flip()
    
        pygame.quit()
        sys.exit()
    
    if __name__ == "__main__":
        main()
    

    Wyjaśnienie kodu:

    • Importy i inicjalizacja: Zaimportowano niezbędne moduły i zainicjowano Pygame oraz mixer do dźwięków.
    • Klasy:
      • Player: Obsługuje ruch, skok, grawitację i kolizje z platformami.
      • Platform: Stałe i ruchome platformy; ruchome poruszają się poziomo między granicami.
      • Enemy: Porusza się poziomo i oscyluje pionowo według funkcji sinus.
      • Star: Proste obiekty do zbierania.
    • Funkcja kolizji: handle_collisions sprawdza kolizje gracza z gwiazdami i wrogami, zwraca punkty lub sygnalizuje śmierć.
    • Główna pętla: Używa delta time dla płynności. Obsługuje menu (start/pauza), input, aktualizacje, kolizje i rysowanie.
    • HUD: Wyświetla wynik w rogu ekranu.
    • Dźwięki: Odtwarzane w odpowiednich momentach (skok, zbieranie, śmierć).
    • Menu: Proste – naciśnięcie SPACE startuje grę, P pauzuje.

    Kod jest kompletny i powinien działać po dodaniu plików dźwiękowych (np. jump.wav). Jeśli pliki dźwiękowe nie istnieją, program nie zgłosi błędu, ale dźwięki nie będą odtwarzane.

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