Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-sonnet-20241022· AnthropicHugging Face LMArena Human Preference 140K

generate a full fledged bullet hell game with infinite waves

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

    generate a full fledged bullet hell game with infinite waves

  2. Claude Assistant

    Here's a complete bullet hell game with infinite waves using Python and Pygame. Players control a ship, dodge enemy bullets, and face increasingly difficult waves of enemies:

    import pygame
    import random
    import math
    from pygame import mixer
    
    # Initialize Pygame
    pygame.init()
    
    # Set up the display
    WIDTH = 800
    HEIGHT = 600
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Bullet Hell")
    
    # Colors
    WHITE = (255, 255, 255)
    RED = (255, 0, 0)
    BLUE = (0, 0, 255)
    BLACK = (0, 0, 0)
    
    # Player
    class Player:
        def __init__(self):
            self.width = 30
            self.height = 30
            self.x = WIDTH // 2
            self.y = HEIGHT - 50
            self.speed = 5
            self.health = 100
            self.bullets = []
    
        def draw(self, screen):
            pygame.draw.polygon(screen, BLUE, [
                (self.x, self.y - self.height//2),
                (self.x - self.width//2, self.y + self.height//2),
                (self.x + self.width//2, self.y + self.height//2)
            ])
    
        def move(self):
            keys = pygame.key.get_pressed()
            if keys[pygame.K_LEFT] and self.x > self.width//2:
                self.x -= self.speed
            if keys[pygame.K_RIGHT] and self.x < WIDTH - self.width//2:
                self.x += self.speed
            if keys[pygame.K_UP] and self.y > self.height//2:
                self.y -= self.speed
            if keys[pygame.K_DOWN] and self.y < HEIGHT - self.height//2:
                self.y += self.speed
    
        def shoot(self):
            self.bullets.append(PlayerBullet(self.x, self.y))
    
    # Enemy
    class Enemy:
        def __init__(self, x, y, pattern):
            self.x = x
            self.y = y
            self.width = 30
            self.height = 30
            self.pattern = pattern
            self.speed = 2
            self.bullets = []
            self.shoot_delay = 30
            self.shoot_counter = 0
    
        def draw(self, screen):
            pygame.draw.rect(screen, RED, (self.x - self.width//2, self.y - self.height//2, self.width, self.height))
    
        def move(self):
            if self.pattern == "sine":
                self.x += math.sin(self.y / 30) * 2
                self.y += self.speed
            elif self.pattern == "zigzag":
                self.x += math.cos(pygame.time.get_ticks() / 200) * 5
                self.y += self.speed
    
        def shoot(self):
            self.shoot_counter += 1
            if self.shoot_counter >= self.shoot_delay:
                self.bullets.append(EnemyBullet(self.x, self.y))
                self.shoot_counter = 0
    
    # Bullets
    class PlayerBullet:
        def __init__(self, x, y):
            self.x = x
            self.y = y
            self.speed = 10
            self.radius = 5
    
        def move(self):
            self.y -= self.speed
    
        def draw(self, screen):
            pygame.draw.circle(screen, BLUE, (int(self.x), int(self.y)), self.radius)
    
    class EnemyBullet:
        def __init__(self, x, y):
            self.x = x
            self.y = y
            self.speed = 5
            self.radius = 3
    
        def move(self):
            self.y += self.speed
    
        def draw(self, screen):
            pygame.draw.circle(screen, RED, (int(self.x), int(self.y)), self.radius)
    
    # Game state
    class Game:
        def __init__(self):
            self.player = Player()
            self.enemies = []
            self.wave = 1
            self.score = 0
            self.spawn_delay = 60
            self.spawn_counter = 0
            self.font = pygame.font.Font(None, 36)
    
        def spawn_enemies(self):
            self.spawn_counter += 1
            if self.spawn_counter >= self.spawn_delay:
                pattern = random.choice(["sine", "zigzag"])
                x = random.randint(50, WIDTH - 50)
                self.enemies.append(Enemy(x, -30, pattern))
                self.spawn_counter = 0
    
        def check_collisions(self):
            # Player bullets hitting enemies
            for bullet in self.player.bullets[:]:
                for enemy in self.enemies[:]:
                    if (abs(bullet.x - enemy.x) < enemy.width//2 and
                        abs(bullet.y - enemy.y) < enemy.height//2):
                        if bullet in self.player.bullets:
                            self.player.bullets.remove(bullet)
                        if enemy in self.enemies:
                            self.enemies.remove(enemy)
                            self.score += 100
    
            # Enemy bullets hitting player
            for enemy in self.enemies:
                for bullet in enemy.bullets[:]:
                    if (abs(bullet.x - self.player.x) < self.player.width//2 and
                        abs(bullet.y - self.player.y) < self.player.height//2):
                        if bullet in enemy.bullets:
                            enemy.bullets.remove(bullet)
                            self.player.health -= 10
    
        def update(self):
            self.spawn_enemies()
            self.player.move()
    
            # Update enemies
            for enemy in self.enemies[:]:
                enemy.move()
                enemy.shoot()
                if enemy.y > HEIGHT + 50:
                    self.enemies.remove(enemy)
    
            # Update bullets
            for bullet in self.player.bullets[:]:
                bullet.move()
                if bullet.y < -10:
                    self.player.bullets.remove(bullet)
    
            for enemy in self.enemies:
                for bullet in enemy.bullets[:]:
                    bullet.move()
                    if bullet.y > HEIGHT + 10:
                        enemy.bullets.remove(bullet)
    
            self.check_collisions()
    
            # Increase difficulty
            if self.score // 1000 > self.wave - 1:
                self.wave += 1
                self.spawn_delay = max(20, self.spawn_delay - 5)
    
        def draw(self, screen):
            screen.fill(BLACK)
            self.player.draw(screen)
    
            for enemy in self.enemies:
                enemy.draw(screen)
                for bullet in enemy.bullets:
                    bullet.draw(screen)
    
            for bullet in self.player.bullets:
                bullet.draw(screen)
    
            # Draw HUD
            score_text = self.font.render(f"Score: {self.score}", True, WHITE)
            wave_text = self.font.render(f"Wave: {self.wave}", True, WHITE)
            health_text = self.font.render(f"Health: {self.player.health}", True, WHITE)
            
            screen.blit(score_text, (10, 10))
            screen.blit(wave_text, (10, 40))
            screen.blit(health_text, (10, 70))
    
    # Main game loop
    def main():
        clock = pygame.time.Clock()
        game = Game()
        running = True
    
        while running:
            # Event handling
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_SPACE:
                        game.player.shoot()
    
            # Game logic
            game.update()
    
            # Check game over
            if game.player.health <= 0:
                running = False
    
            # Drawing
            game.draw(screen)
            pygame.display.flip()
    
            # Cap the frame rate
            clock.tick(60)
    
        pygame.quit()
    
    if __name__ == "__main__":
        main()
    

    This game includes:

    1. A player-controlled ship that can move in all directions and shoot
    2. Different types of enemies with varying movement patterns
    3. Enemy bullets
    4. Collision detection
    5. Score system
    6. Wave system with increasing difficulty
    7. Health system
    8. Basic HUD showing score, wave, and health

    To play:

    • Use arrow keys to move
    • Space to shoot
    • Avoid enemy bullets
    • Shoot enemies to score points
    • Survive as long as possible

    The difficulty increases as you progress through waves, with:

    • More frequent enemy spawns
    • Different enemy movement patterns
    • Increasing challenge

    You can enhance this game by adding:

    1. Power-ups
    2. Different bullet patterns
    3. Boss battles
    4. Sound effects and music
    5. Graphics instead of shapes
    6. Menu system
    7. High score system
    8. Different enemy types
    9. Screen shake effects
    10. Particle effects

    Feel free to modify and expand upon this base code to add more features and make it your own!

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

Identical first prompt