Board logo

標題: Google Gemini 新模型 2.5 Pro 處理複雜問題 [打印本頁]
作者: javacomhk    時間: 2025-4-1 13:00     標題: Google Gemini 新模型 2.5 Pro 處理複雜問題

本帖最後由 javacomhk 於 2025-4-1 11:10 編輯

[attach]2471820[/attach]

編碼能力領先 OpenAI 、 Claude 及 Grok3
[attach]2471821[/attach]

測試 Google Gemini Programming task 的 tetrasnake.py
Comparing it with Grok 3 code at https://x.ai/news/grok-3
Prompt:
Create a game that is a mixture of two classic games. Make it in pygame with sound effects and make it look pretty.
  1. import pygame
  2. import random
  3. import sys # Needed for sys.exit()

  5. # --- Constants ---
  6. SCREEN_WIDTH = 400
  7. SCREEN_HEIGHT = 600
  8. GRID_SIZE = 30
  9. GRID_WIDTH = SCREEN_WIDTH // GRID_SIZE # Grid dimensions in cells
  10. GRID_HEIGHT = SCREEN_HEIGHT // GRID_SIZE

  12. # Center the grid horizontally
  13. BOARD_WIDTH = 10 # Width of the playable Tetris area
  14. BOARD_HEIGHT = 20 # Height of the playable Tetris area (visible)
  15. BOARD_X_OFFSET = (GRID_WIDTH - BOARD_WIDTH) // 2
  16. BOARD_Y_OFFSET = (GRID_HEIGHT - BOARD_HEIGHT) # Keep board aligned to bottom for snake

  18. # Colors (Can be customized for a prettier look)
  19. WHITE = (255, 255, 255)
  20. BLACK = (0, 0, 0)
  21. GRAY = (128, 128, 128)
  22. CYAN = (0, 255, 255)
  23. BLUE = (0, 0, 255)
  24. ORANGE = (255, 165, 0)
  25. YELLOW = (255, 255, 0)
  26. GREEN = (0, 255, 0)
  27. PURPLE = (128, 0, 128)
  28. RED = (255, 0, 0)
  29. SNAKE_HEAD_COLOR = (200, 200, 0) # Distinct color for snake head
  30. SNAKE_BODY_COLOR = YELLOW # Use Tetris yellow for consistency

  32. # Tetromino Shapes (coordinates relative to top-left pivot)
  33. SHAPES = [
  34.     [[1, 1, 1, 1]], # I
  35.     [[1, 1], [1, 1]], # O
  36.     [[0, 1, 0], [1, 1, 1]], # T
  37.     [[1, 0, 0], [1, 1, 1]], # L
  38.     [[0, 0, 1], [1, 1, 1]], # J
  39.     [[0, 1, 1], [1, 1, 0]], # S
  40.     [[1, 1, 0], [0, 1, 1]]  # Z
  41. ]

  43. SHAPE_COLORS = [CYAN, YELLOW, PURPLE, ORANGE, BLUE, GREEN, RED] # Colors corresponding to SHAPES

  45. # Game Settings
  46. INITIAL_FALL_SPEED = 500 # Milliseconds per grid step down
  47. SPEED_INCREMENT = 20 # Speed increase per line clear
  48. MIN_FALL_SPEED = 100 # Fastest speed
  49. INITIAL_SNAKE_LENGTH = 3

  51. # --- Sound Effect Placeholders ---
  52. # Replace 'None' with loaded sound objects using pygame.mixer.Sound('path/to/sound.wav')
  53. # You'll need to find or create these sound files (.wav or .ogg recommended)
  54. try:
  55.     pygame.mixer.init()
  56.     # move_sound = pygame.mixer.Sound('sounds/move.wav') # Example
  57.     # rotate_sound = pygame.mixer.Sound('sounds/rotate.wav') # Example
  58.     lock_sound = pygame.mixer.Sound('sounds/lock.wav') if pygame.mixer.get_init() else None
  59.     clear_sound = pygame.mixer.Sound('sounds/clear.wav') if pygame.mixer.get_init() else None
  60.     grow_sound = pygame.mixer.Sound('sounds/grow.wav') if pygame.mixer.get_init() else None
  61.     game_over_sound = pygame.mixer.Sound('sounds/game_over.wav') if pygame.mixer.get_init() else None
  62.     # Background music?
  63.     # pygame.mixer.music.load('sounds/background.ogg')
  64.     # pygame.mixer.music.play(-1) # Loop indefinitely
  65. except pygame.error as e:
  66.     print(f"Warning: Could not initialize mixer or load sounds: {e}")
  67.     lock_sound, clear_sound, grow_sound, game_over_sound = None, None, None, None

  69. def play_sound(sound):
  70.     """Safely plays a sound effect if it's loaded."""
  71.     if sound:
  72.         sound.play()

  74. # --- Classes ---
  75. class Tetromino:
  76.     def __init__(self, x, y, shape_index):
  77.         self.x = x
  78.         self.y = y
  79.         self.shape_index = shape_index
  80.         self.shape = SHAPES[shape_index]
  81.         self.color = SHAPE_COLORS[shape_index]
  82.         self.rotation = 0 # Not implementing rotation for falling pieces in this version yet

  84.     def draw(self, surface, grid_x_offset, grid_y_offset):
  85.         for r_idx, row in enumerate(self.shape):
  86.             for c_idx, cell in enumerate(row):
  87.                 if cell:
  88.                     pygame.draw.rect(
  89.                         surface,
  90.                         self.color,
  91.                         (
  92.                             (self.x + c_idx + grid_x_offset) * GRID_SIZE,
  93.                             (self.y + r_idx + grid_y_offset) * GRID_SIZE,
  94.                             GRID_SIZE - 1, # -1 for grid lines
  95.                             GRID_SIZE - 1
  96.                         )
  97.                     )
  98.                     # Add a slightly darker border for definition
  99.                     pygame.draw.rect(
  100.                         surface,
  101.                         tuple(max(0, c-50) for c in self.color), # Darker color
  102.                         (
  103.                             (self.x + c_idx + grid_x_offset) * GRID_SIZE,
  104.                             (self.y + r_idx + grid_y_offset) * GRID_SIZE,
  105.                             GRID_SIZE - 1,
  106.                             GRID_SIZE - 1
  107.                         ), 1 # Border width
  108.                     )

  110.     def move(self, dx, dy):
  111.         self.x += dx
  112.         self.y += dy

  114.     def get_block_positions(self):
  115.         """Returns list of (x, y) grid coordinates for each block in the piece."""
  116.         positions = []
  117.         for r_idx, row in enumerate(self.shape):
  118.             for c_idx, cell in enumerate(row):
  119.                 if cell:
  120.                     positions.append((self.x + c_idx, self.y + r_idx))
  121.         return positions

  123. class Snake:
  124.     def __init__(self, initial_x, initial_y, length):
  125.         self.segments = [(initial_x - i, initial_y) for i in range(length)] # Head is at index 0
  126.         self.direction = (1, 0) # Initial movement (not used for player control here)
  127.         self.head_color = SNAKE_HEAD_COLOR
  128.         self.body_color = SNAKE_BODY_COLOR

  130.     def move(self, dx):
  131.         """Moves the entire snake horizontally."""
  132.         new_segments = []
  133.         can_move = True
  134.         for i, (sx, sy) in enumerate(self.segments):
  135.             new_x = sx + dx
  136.             # Basic boundary check (adjust if needed for board offset)
  137.             if not (0 <= new_x < BOARD_WIDTH):
  138.                  can_move = False
  139.                  break
  140.             new_segments.append((new_x, sy))

  142.         if can_move:
  143.             self.segments = new_segments
  144.             # play_sound(move_sound) # Sound for snake move

  146.     def grow(self, amount=1):
  147.         """Adds segments to the tail."""
  148.         if not self.segments: return # Cannot grow if snake doesn't exist

  150.         # Determine tail direction to add new segment logically
  151.         # (Simplification: always add to the 'left' based on current list order)
  152.         last_x, last_y = self.segments[-1]
  153.         # We'll just add it conceptually off-screen left, it'll correct position on next move?
  154.         # Or better: find the leftmost segment and add left of that.
  155.         min_x = min(x for x, y in self.segments)
  156.         new_segment_pos = (min_x - 1, last_y) # Add left of the leftmost block
  157.         
  158.         # Check if new segment position is valid (within bounds) - It might initially be outside!
  159.         # We rely on the next player move to bring it potentially back into bounds.
  160.         # A better approach might be needed if snake wraps or complex growth is desired.
  161.         
  162.         for _ in range(amount):
  163.              self.segments.append(new_segment_pos) # Add multiple segments if needed
  164.              new_segment_pos = (new_segment_pos[0] - 1, new_segment_pos[1]) # Continue left
  165.         play_sound(grow_sound)

  167.     def draw(self, surface, grid_x_offset, grid_y_offset):
  168.         for i, (x, y) in enumerate(self.segments):
  169.              # Only draw segments within the visible board area
  170.              if 0 <= x < BOARD_WIDTH and 0 <= y < BOARD_HEIGHT :
  171.                 color = self.head_color if i == 0 else self.body_color
  172.                 # Draw slightly smaller rects for grid effect
  173.                 pygame.draw.rect(
  174.                     surface,
  175.                     color,
  176.                     (
  177.                         (x + grid_x_offset) * GRID_SIZE,
  178.                         (y + grid_y_offset) * GRID_SIZE,
  179.                         GRID_SIZE - 1,
  180.                         GRID_SIZE - 1
  181.                     )
  182.                 )
  183.                 # Border
  184.                 pygame.draw.rect(
  185.                     surface,
  186.                     tuple(max(0, c-50) for c in color),
  187.                     (
  188.                         (x + grid_x_offset) * GRID_SIZE,
  189.                         (y + grid_y_offset) * GRID_SIZE,
  190.                         GRID_SIZE - 1,
  191.                         GRID_SIZE - 1
  192.                     ), 1
  193.                 )


  196.     def get_head_pos(self):
  197.         return self.segments[0] if self.segments else None

  199.     def get_body_positions(self):
  200.         return self.segments[1:] if len(self.segments) > 1 else []
  201.    
  202.     def get_all_positions(self):
  203.         return self.segments

  205. # --- Game Functions ---

  207. def create_grid(locked_positions={}):
  208.     """Create the board grid structure."""
  209.     grid = [[BLACK for _ in range(BOARD_WIDTH)] for _ in range(BOARD_HEIGHT)] # Visible grid

  211.     # Fill grid with colors of locked pieces
  212.     for y in range(BOARD_HEIGHT):
  213.         for x in range(BOARD_WIDTH):
  214.             if (x, y) in locked_positions:
  215.                 color = locked_positions[(x, y)]
  216.                 grid[y][x] = color
  217.     return grid

  219. def draw_grid(surface, grid, grid_x_offset, grid_y_offset):
  220.     """Draw the grid lines."""
  221.     for y in range(BOARD_HEIGHT):
  222.         for x in range(BOARD_WIDTH):
  223.              # Draw cell background (already done by filling 'grid' in create_grid)
  224.              pygame.draw.rect(
  225.                  surface,
  226.                  grid[y][x],
  227.                  (
  228.                      (x + grid_x_offset) * GRID_SIZE,
  229.                      (y + grid_y_offset) * GRID_SIZE,
  230.                      GRID_SIZE,
  231.                      GRID_SIZE
  232.                  ),
  233.                  0 # Fill the cell
  234.              )
  235.              # Draw border for the cell
  236.              pygame.draw.rect(
  237.                  surface,
  238.                  GRAY, # Grid line color
  239.                  (
  240.                      (x + grid_x_offset) * GRID_SIZE,
  241.                      (y + grid_y_offset) * GRID_SIZE,
  242.                      GRID_SIZE,
  243.                      GRID_SIZE
  244.                  ),
  245.                  1 # Border width
  246.              )

  248. def draw_window(surface, grid, score=0, snake=None, current_piece=None, next_piece=None):
  249.     """Draws all elements onto the screen."""
  250.     surface.fill(BLACK) # Background

  252.     # Title
  253.     font = pygame.font.SysFont('comicsans', 40)
  254.     label = font.render('TetraSnake', 1, WHITE)
  255.     surface.blit(label, (SCREEN_WIDTH / 2 - label.get_width() / 2, 15))

  257.     # Draw the Play Area Grid and locked pieces
  258.     draw_grid(surface, grid, BOARD_X_OFFSET, BOARD_Y_OFFSET)

  260.     # Draw the falling piece
  261.     if current_piece:
  262.         current_piece.draw(surface, BOARD_X_OFFSET, BOARD_Y_OFFSET)

  264.     # Draw the snake
  265.     if snake:
  266.         snake.draw(surface, BOARD_X_OFFSET, BOARD_Y_OFFSET)

  268.     # Draw Score
  269.     score_label = font.render(f'Score: {score}', 1, WHITE)
  270.     sx = SCREEN_WIDTH - score_label.get_width() - 20
  271.     sy = 50 # Position score top right
  272.     surface.blit(score_label, (sx, sy))

  274.     # Draw Next Piece (optional - needs UI space)
  275.     if next_piece:
  276.         nx_label = pygame.font.SysFont('comicsans', 25).render('Next:', 1, WHITE)
  277.         nx_x = SCREEN_WIDTH - nx_label.get_width() - 40
  278.         nx_y = 100
  279.         surface.blit(nx_label, (nx_x, nx_y))
  280.         # Adjust position for drawing the small preview piece
  281.         preview_piece = Tetromino(0, 0, next_piece.shape_index) # Temp piece for drawing
  282.         preview_piece.draw(surface, (nx_x // GRID_SIZE) + 1, (nx_y // GRID_SIZE) + 1)


  285.     # Update the display
  286.     # pygame.display.update() # Use flip() at end of main loop instead for full screen update

  288. def get_new_piece():
  289.     """Returns a new random Tetromino at the top center."""
  290.     shape_idx = random.randint(0, len(SHAPES) - 1)
  291.     # Start piece above the visible grid
  292.     start_x = BOARD_WIDTH // 2 - len(SHAPES[shape_idx][0]) // 2
  293.     start_y = 0 # Start at the very top row
  294.     return Tetromino(start_x, start_y, shape_idx)

  296. def is_valid_position(piece, grid, locked_positions, snake):
  297.     """Checks if the piece is in a valid position (within bounds, not overlapping)."""
  298.     accepted_pos = [[(x, y) for x in range(BOARD_WIDTH) if y >= 0] for y in range(BOARD_HEIGHT)]
  299.     accepted_pos = [item for sublist in accepted_pos for item in sublist] # Flatten

  301.     formatted = piece.get_block_positions()

  303.     for pos in formatted:
  304.         x, y = pos
  305.         if x < 0 or x >= BOARD_WIDTH or y >= BOARD_HEIGHT: # Check bounds (allow y<0 initially)
  306.             return False
  307.         if y >= 0: # Only check grid/locked if within visible area
  308.              # Check collision with locked pieces
  309.              if (x, y) in locked_positions:
  310.                  return False
  311.              # Check collision with snake's body (not head)
  312.              if snake and pos in snake.get_body_positions():
  313.                  return False # Cannot land on snake body yet (becomes locked)


  316.     return True

  318. def check_lost(locked_positions, snake):
  319.     """Checks if the game is over."""
  320.     # 1. Block reached the top
  321.     for x, y in locked_positions:
  322.         if y < 1: # Piece locked in the topmost row (or above)
  323.             return True
  324.             
  325.     # 2. Falling piece collided with snake head (handled during locking) - Implicitly checked below

  327.     # 3. Snake collided with itself (not implemented)

  329.     return False

  331. def clear_lines(grid, locked_positions):
  332.     """Checks for and clears completed lines, returns number of lines cleared."""
  333.     lines_cleared = 0
  334.     full_rows = []

  336.     # Check from bottom up
  337.     for y in range(BOARD_HEIGHT - 1, -1, -1):
  338.         row_full = True
  339.         for x in range(BOARD_WIDTH):
  340.             if (x, y) not in locked_positions:
  341.                 row_full = False
  342.                 break
  343.         if row_full:
  344.             lines_cleared += 1
  345.             full_rows.append(y)
  346.             play_sound(clear_sound)
  347.             # Mark row for clearing visually (optional flashing effect could go here)
  348.             for x in range(BOARD_WIDTH):
  349.                  # Temporarily change color? Or handle in draw loop
  350.                  pass


  353.     if lines_cleared > 0:
  354.         # Remove cleared rows from locked_positions
  355.         new_locked = {}
  356.         rows_to_shift = sorted(full_rows) # Sort ascending for correct shifting

  358.         for (x, y), color in locked_positions.items():
  359.             if y not in rows_to_shift:
  360.                  # Calculate how many cleared rows were below this position
  361.                  shift_down = sum(1 for cleared_y in rows_to_shift if cleared_y > y)
  362.                  new_locked[(x, y + shift_down)] = color # Add shifted block to new dict
  363.         
  364.         return lines_cleared, new_locked

  366.     return 0, locked_positions # No lines cleared, return original


  369. def draw_text_middle(surface, text, size, color):
  370.     font = pygame.font.SysFont('comicsans', size, bold=True)
  371.     label = font.render(text, 1, color)
  372.     surface.blit(label, (SCREEN_WIDTH / 2 - label.get_width() / 2, SCREEN_HEIGHT / 2 - label.get_height() / 2))

  374. # --- Main Game Loop ---
  375. def main():
  376.     pygame.init()
  377.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  378.     pygame.display.set_caption("TetraSnake")

  380.     locked_positions = {} # (x, y): color
  381.     grid = create_grid(locked_positions)

  383.     change_piece = False
  384.     run = True
  385.     current_piece = get_new_piece()
  386.     next_piece = get_new_piece()
  387.     clock = pygame.time.Clock()
  388.     fall_time = 0
  389.     fall_speed = INITIAL_FALL_SPEED
  390.     level_time = 0 # Could be used for speed increase over time too
  391.     score = 0

  393.     # Initialize Snake at the bottom center
  394.     snake_start_y = BOARD_HEIGHT - 1 # Last row
  395.     snake_start_x = BOARD_WIDTH // 2
  396.     player_snake = Snake(snake_start_x, snake_start_y, INITIAL_SNAKE_LENGTH)

  398.     game_over = False

  400.     while run:
  401.         grid = create_grid(locked_positions) # Update grid based on locked pieces
  402.         fall_time += clock.get_rawtime() # Time since last frame
  403.         level_time += clock.get_rawtime()
  404.         clock.tick() # Control FPS (let Pygame manage it)

  406.         # --- Automatic Falling ---
  407.         if not game_over and fall_time / 1000 * (1000 / fall_speed) >= 1: # Time based fall
  408.             fall_time = 0
  409.             current_piece.move(0, 1) # Move down one step
  410.             
  411.             # Check if landed
  412.             if not is_valid_position(current_piece, grid, locked_positions, player_snake):
  413.                 current_piece.move(0, -1) # Move back up
  414.                
  415.                 # Check for collision with Snake Head -> Game Over
  416.                 piece_blocks = current_piece.get_block_positions()
  417.                 snake_head = player_snake.get_head_pos()
  418.                 if snake_head and any(block == snake_head for block in piece_blocks):
  419.                      game_over = True
  420.                      play_sound(game_over_sound)
  421.                      # Optional: Show piece overlapping head briefly
  422.                      draw_window(screen, grid, score, player_snake, current_piece, next_piece)
  423.                      pygame.display.flip()
  424.                      pygame.time.wait(500) # Short pause
  425.                
  426.                 if not game_over:
  427.                     # Lock the piece
  428.                     for pos in piece_blocks:
  429.                         x, y = pos
  430.                         if y >= 0: # Only lock blocks within the visible grid
  431.                            locked_positions[(x, y)] = current_piece.color
  432.                     play_sound(lock_sound)
  433.                     change_piece = True # Signal to get a new piece


  436.         # --- Event Handling ---
  437.         for event in pygame.event.get():
  438.             if event.type == pygame.QUIT:
  439.                 run = False
  440.                 pygame.quit()
  441.                 sys.exit()

  443.             if event.type == pygame.KEYDOWN:
  444.                  if not game_over:
  445.                      if event.key == pygame.K_LEFT:
  446.                          player_snake.move(-1)
  447.                          # Check snake collision with locked pieces after move (optional for difficulty)
  448.                          # If head hits a locked piece? Maybe game over?

  450.                      elif event.key == pygame.K_RIGHT:
  451.                           player_snake.move(1)
  452.                           # Check snake collision...

  454.                      # Tetris Controls (Apply to falling piece) - Can be complex with snake
  455.                      # For simplicity, let's *not* allow player control of falling piece for now
  456.                      # Focus on snake movement first.

  458.                      # elif event.key == pygame.K_DOWN: # Soft drop
  459.                      #     current_piece.move(0, 1)
  460.                      #     if not is_valid_position(current_piece, grid, locked_positions, player_snake):
  461.                      #         current_piece.move(0, -1) # Undo if invalid
  462.                      
  463.                      # elif event.key == pygame.K_UP: # Rotate (Harder to implement correctly)
  464.                      #     # Add rotation logic here
  465.                      #     pass # play_sound(rotate_sound)

  467.                      # elif event.key == pygame.K_SPACE: # Hard drop
  468.                      #      while is_valid_position(current_piece, grid, locked_positions, player_snake):
  469.                      #          current_piece.move(0, 1)
  470.                      #      current_piece.move(0, -1) # Move back one step
  471.                      #      # Lock piece immediately after hard drop (similar logic to landing)
  472.                      #      piece_blocks = current_piece.get_block_positions()
  473.                      #      if snake_head and any(block == snake_head for block in piece_blocks):
  474.                      #          game_over = True
  475.                      #          play_sound(game_over_sound)
  476.                      #      else:
  477.                      #          for pos in piece_blocks:
  478.                      #               x,y = pos
  479.                      #               if y >=0: locked_positions[(x,y)] = current_piece.color
  480.                      #          play_sound(lock_sound)
  481.                      #          change_piece = True


  484.                  if game_over and event.key == pygame.K_RETURN: # Restart game
  485.                      main() # Call main again to reset everything


  488.         # --- Piece Locking and New Piece ---
  489.         if change_piece and not game_over:
  490.             # Check for cleared lines BEFORE getting the new piece
  491.             lines_cleared, locked_positions = clear_lines(grid, locked_positions)
  492.             
  493.             if lines_cleared > 0:
  494.                  score += lines_cleared * 10 # Simple scoring
  495.                  player_snake.grow(lines_cleared * 4) # Grow snake by blocks cleared (4 per line avg?)
  496.                  # Increase speed
  497.                  fall_speed = max(MIN_FALL_SPEED, fall_speed - (SPEED_INCREMENT * lines_cleared))


  500.             # Get the next piece
  501.             current_piece = next_piece
  502.             next_piece = get_new_piece()
  503.             change_piece = False

  505.             # Check if the new piece immediately causes a loss (spawn overlap)
  506.             if not is_valid_position(current_piece, grid, locked_positions, player_snake):
  507.                 game_over = True
  508.                 play_sound(game_over_sound)

  510.         # --- Game Over Check ---
  511.         if not game_over:
  512.             # Check loss condition based on locked pieces height (redundant with spawn check?)
  513.              if check_lost(locked_positions, player_snake):
  514.                 game_over = True
  515.                 play_sound(game_over_sound)


  518.         # --- Drawing ---
  519.         draw_window(screen, grid, score, player_snake, current_piece, next_piece)

  521.         if game_over:
  522.             draw_text_middle(screen, "GAME OVER!", 80, RED)
  523.             draw_text_middle(screen, f"Score: {score}", 50, WHITE, y_offset=50) # Offset score display
  524.             draw_text_middle(screen, "Press ENTER to Play Again", 30, WHITE, y_offset=100)


  527.         pygame.display.flip() # Update the full screen

  529. # Function to draw text with offset easily
  530. def draw_text_middle(surface, text, size, color, y_offset=0):
  531.     font = pygame.font.SysFont('comicsans', size, bold=True)
  532.     label = font.render(text, 1, color)
  533.     text_rect = label.get_rect(center=(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + y_offset))
  534.     surface.blit(label, text_rect)


  537. if __name__ == "__main__":
  538.     main()
複製代碼




歡迎光臨 電腦領域 HKEPC Hardware (https://h2.hkepc.com/forum/) Powered by Discuz! 7.2