devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python实现的一些小游戏_python自制小游戏

作者：很楠不爱3 | 2024-02-15 13:12:13

赞

踩

python自制小游戏

以下内容为使用Python开发的一些小游戏，仅供参考，谢谢！

猜单词游戏

  1. import random
  2.  
  3. # 单词列表
  4. words = ['apple', 'banana', 'cherry', 'orange', 'pear', 'watermelon']
  5.  
  6. # 随机选一个单词
  7. word = random.choice(words)
  8.  
  9. # 将单词转换为小写字母
  10. word = word.lower()
  11.  
  12. # 猜测次数限制
  13. max_guesses = 10
  14.  
  15. # 玩家猜测的次数
  16. guesses = 0
  17.  
  18. # 玩家猜测的字母集合
  19. letters_guessed = set()
  20.  
  21. # 游戏是否结束的标志
  22. game_over = False
  23.  
  24. print('猜单词游戏！')
  25. print('我想了一个单词，这个单词有', len(word), '个字母。')
  26.  
  27. while not game_over:
  28.     # 显示玩家已经猜过的字母
  29.     print('你已经猜过的字母：', ' '.join(sorted(letters_guessed)))
  30.  
  31.     # 显示单词中已经猜中的字母
  32.     display_word = ''
  33.     for letter in word:
  34.         if letter in letters_guessed:
  35.             display_word += letter
  36.         else:
  37.             display_word += '_'
  38.     print(display_word)
  39.  
  40.     # 等待玩家猜测
  41.     guess = input('你猜这个单词是什么？')
  42.  
  43.     # 判断玩家猜测的是字母还是单词
  44.     if len(guess) == 1:
  45.         # 玩家猜测的是字母
  46.         letter = guess.lower()
  47.         if letter in letters_guessed:
  48.             print('你已经猜过这个字母了，请猜一个新的字母。')
  49.         else:
  50.             letters_guessed.add(letter)
  51.             if letter in word:
  52.                 print('恭喜你，你猜对了一个字母！')
  53.             else:
  54.                 print('很遗憾，这个字母不在单词中。')
  55.             guesses += 1
  56.     else:
  57.         # 玩家猜测的是单词
  58.         if guess.lower() == word:
  59.             print('恭喜你，你猜对了整个单词！')
  60.             game_over = True
  61.         else:
  62.             print('很遗憾，你猜错了整个单词。')
  63.             guesses += 1
  64.  
  65.     # 判断游戏是否结束
  66.     if guesses >= max_guesses:
  67.         print('很遗憾，你已经猜测了', max_guesses, '次，游戏结束。')
  68.         game_over = True
  69.     elif set(word) == letters_guessed:
  70.         print('恭喜你，你猜对了整个单词！')
  71.         game_over = True

猜数字游戏

  1. import random
  2.  
  3. number = random.randint(1, 100)
  4. guesses = 0
  5.  
  6. print('猜数字游戏！')
  7. print('我想了一个 1 到 100 之间的整数。')
  8.  
  9. while True:
  10.     guess = int(input('你猜这个数字是多少？'))
  11.  
  12.     guesses += 1
  13.  
  14.     if guess < number:
  15.         print('猜小了！')
  16.     elif guess > number:
  17.         print('猜大了！')
  18.     else:
  19.         print('恭喜你猜对了！')
  20.         break
  21.  
  22. print('你总共猜了', guesses, '次。')

黑白棋游戏

  1. # 定义棋盘的大小
  2. BOARD_SIZE = 8
  3.  
  4. # 定义棋子的颜色
  5. EMPTY = 0
  6. BLACK = 1
  7. WHITE = 2
  8.  
  9. # 初始化棋盘
  10. board = [[EMPTY for x in range(BOARD_SIZE)] for y in range(BOARD_SIZE)]
  11. board[3][3] = WHITE
  12. board[4][4] = WHITE
  13. board[3][4] = BLACK
  14. board[4][3] = BLACK
  15.  
  16. # 定义可以翻转对手棋子的方向
  17. DIRECTIONS = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1))
  18.  
  19. # 定义玩家的颜色
  20. player_color = BLACK
  21.  
  22. # 定义游戏是否结束的标志
  23. game_over = False
  24.  
  25. # 统计棋盘上各种颜色的棋子数
  26. def count_pieces(board):
  27.     black_count = 0
  28.     white_count = 0
  29.     for row in board:
  30.         for cell in row:
  31.             if cell == BLACK:
  32.                 black_count += 1
  33.             elif cell == WHITE:
  34.                 white_count += 1
  35.     return (black_count, white_count)
  36.  
  37. # 判断落子是否合法
  38. def is_legal_move(board, row, col, color):
  39.     if board[row][col] != EMPTY:
  40.         return False
  41.     for direction in DIRECTIONS:
  42.         r, c = row + direction[0], col + direction[1]
  43.         if (r < 0 or r >= BOARD_SIZE or c < 0 or c >= BOARD_SIZE or board[r][c] == EMPTY or board[r][c] == color):
  44.             continue
  45.         r += direction[0]
  46.         c += direction[1]
  47.         while (r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] != EMPTY):
  48.             if (board[r][c] == color):
  49.                 return True
  50.             r += direction[0]
  51.             c += direction[1]
  52.     return False
  53.  
  54. # 翻转对手的棋子
  55. def flip_pieces(board, row, col, color):
  56.     for direction in DIRECTIONS:
  57.         r, c = row + direction[0], col + direction[1]
  58.         if (r < 0 or r >= BOARD_SIZE or c < 0 or c >= BOARD_SIZE or board[r][c] == EMPTY or board[r][c] == color):
  59.             continue
  60.         r += direction[0]
  61.         c += direction[1]
  62.         while (r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] != EMPTY):
  63.             if (board[r][c] == color):
  64.                 r2, c2 = row + direction[0], col + direction[1]
  65.                 while (r2 != r or c2 != c):
  66.                     board[r2][c2] = color
  67.                     r2 += direction[0]
  68.                     c2 += direction[1]
  69.                 break
  70.             r += direction[0]
  71.             c += direction[1]
  72.  
  73. # 输出棋盘
  74. def print_board(board):
  75.     print('   ', end='')
  76.     for i in range(BOARD_SIZE):
  77.         print(chr(ord('a') + i), end=' ')
  78.     print()
  79.     print('  +' + '-' * (2 * BOARD_SIZE - 1) + '+')
  80.     for i in range(BOARD_SIZE):
  81.         print(str(i + 1) + ' |', end='')
  82.         for j in range(BOARD_SIZE):
  83.             if board[i][j] == EMPTY:
  84.                 print(' ', end='')
  85.             elif board[i][j] == BLACK:
  86.                 print('●', end='')
  87.             elif board[i][j] == WHITE:
  88.                 print('○', end='')
  89.             if j < BOARD_SIZE - 1:
  90.                 print(' ', end='')
  91.         print('| ' + str(i + 1))
  92.     print(' +-' + '-' * (2 * BOARD_SIZE - 1) + '-+')
  93.     print('   ', end='')
  94.     for i in range(BOARD_SIZE):
  95.         print(chr(ord('a') + i), end=' ')
  96.     print()
  97.  
  98. # 主循环
  99. while not game_over:
  100.     # 输出当前棋盘和玩家的颜色
  101.     print_board(board)
  102.     if player_color == BLACK:
  103.         print("黑方落子")
  104.     else:
  105.         print("白方落子")
  106.  
  107.     # 等待玩家落子
  108.     while True:
  109.         move = input("请输入落子位置（例如d3）或输入pass跳过本回合：")
  110.         if move.lower() == "pass":
  111.             break
  112.         col = ord(move[0]) - ord('a')
  113.         row = int(move[1:]) - 1
  114.         if (col < 0 or col >= BOARD_SIZE or row < 0 or row >= BOARD_SIZE or not is_legal_move(board, row, col, player_color)):
  115.             print("无效落子，请重新输入。")
  116.         else:
  117.             board[row][col] = player_color
  118.             flip_pieces(board, row, col, player_color)
  119.             break
  120.  
  121.     # 判断游戏是否结束
  122.     black_count, white_count = count_pieces(board)
  123.     if (black_count == 0 or white_count == 0 or black_count + white_count == BOARD_SIZE * BOARD_SIZE):
  124.         game_over = True
  125.  
  126.     # 切换玩家的颜色
  127.     if player_color == BLACK:
  128.         player_color = WHITE
  129.     else:
  130.         player_color = BLACK
  131.  
  132. # 输出最终的棋盘和胜者
  133. print_board(board)
  134. black_count, white_count = count_pieces(board)
  135. if black_count == white_count:
  136.     print("平局")
  137. elif black_count > white_count:
  138.     print("黑方胜利")
  139. else:
  140.     print("白方胜利")

在上面的代码中，我们首先定义了棋盘的大小和棋子的颜色，然后初始化了棋盘和玩家的颜色。游戏的主循环中，我们输出当前棋盘和玩家的颜色，等待玩家落子。如果玩家输入的落子位置合法，我们就将落子放在棋盘上，并翻转对手的一些棋子。然后，我们判断游戏是否结束。如果棋盘上只剩下一种颜色的棋子，或者棋盘上的格子都被占满了，游戏就结束。最后，我们输出最终的棋盘和胜者。

2048

  1. import random
  2.  
  3. # 定义方格的大小
  4. SIZE = 4
  5.  
  6. # 初始化方格
  7. board = [[0 for x in range(SIZE)] for y in range(SIZE)]
  8.  
  9. # 随机生成两个数字块
  10. def init_board():
  11.     for i in range(2):
  12.         row = random.randint(0, SIZE - 1)
  13.         col = random.randint(0, SIZE - 1)
  14.         while board[row][col] != 0:
  15.             row = random.randint(0, SIZE - 1)
  16.             col = random.randint(0, SIZE - 1)
  17.         board[row][col] = 2
  18.  
  19. # 输出方格
  20. def print_board():
  21.     for row in board:
  22.         for cell in row:
  23.             print(cell, end='\t')
  24.         print()
  25.     print()
  26.  
  27. # 判断方格是否已满
  28. def is_full():
  29.     for row in board:
  30.         for cell in row:
  31.             if cell == 0:
  32.                 return False
  33.     return True
  34.  
  35. # 在方格中随机生成一个数字块
  36. def spawn_block():
  37.     while True:
  38.         row = random.randint(0, SIZE - 1)
  39.         col = random.randint(0, SIZE - 1)
  40.         if board[row][col] == 0:
  41.             board[row][col] = 2 if random.random() < 0.9 else 4
  42.             break
  43.  
  44. # 判断方格是否可以移动
  45. def can_move():
  46.     for row in range(SIZE):
  47.         for col in range(SIZE):
  48.             if board[row][col] == 0:
  49.                 return True
  50.             if col > 0 and board[row][col] == board[row][col - 1]:
  51.                 return True
  52.             if col < SIZE - 1 and board[row][col] == board[row][col + 1]:
  53.                 return True
  54.             if row > 0 and board[row][col] == board[row - 1][col]:
  55.                 return True
  56.             if row < SIZE - 1 and board[row][col] == board[row + 1][col]:
  57.                 return True
  58.     return False
  59.  
  60. # 合并相同的数字块
  61. def merge_blocks():
  62.     for row in range(SIZE):
  63.         for col in range(SIZE - 1):
  64.             if board[row][col] != 0 and board[row][col] == board[row][col + 1]:
  65.                 board[row][col] *= 2
  66.                 board[row][col + 1] = 0
  67.     for row in range(SIZE):
  68.         for col in range(SIZE - 1, 0, -1):
  69.             if board[row][col] == 0:
  70.                 for i in range(col - 1, -1, -1):
  71.                     if board[row][i] != 0:
  72.                         board[row][col], board[row][i] = board[row][i], board[row][col]
  73.                         break
  74.  
  75. # 处理玩家移动
  76. def handle_move(move):
  77.     if move == 'w':
  78.         for col in range(SIZE):
  79.             for row in range(SIZE - 1):
  80.                 if board[row][col] == 0:
  81.                     for i in range(row + 1, SIZE):
  82.                         if board[i][col] != 0:
  83.                             board[row][col], board[i][col] = board[i][col], board[row][col]
  84.                             break
  85.         merge_blocks()
  86.     elif move == 's':
  87.         for col in range(SIZE):
  88.             for row in range(SIZE - 1, 0, -1):
  89.                 if board[row][col] == 0:
  90.                     for i in range(row - 1, -1, -1):
  91.                         if board[i][col] != 0:
  92.                             board[row][col], board[i][col] = board[i][col], board[row][col]
  93.                             break
  94.         merge_blocks()
  95.     elif move == 'a':
  96.         for row in range(SIZE):
  97.             for col in range(SIZE - 1):
  98.                 if board[row][col] == 0:
  99.                     for i in range(col + 1, SIZE):
  100.                         if board[row][i] != 0:
  101.                             board[row][col], board[row][i] = board[row][i], board[row][col]
  102.                             break
  103.         merge_blocks()
  104.     elif move == 'd':
  105.         for row in range(SIZE):
  106.             for col in range(SIZE - 1, 0, -1):
  107.                 if board[row][col] == 0:
  108.                     for i in range(col - 1, -1, -1):
  109.                         if board[row][i] != 0:
  110.                             board[row][col], board[row][i] = board[row][i], board[row][col]
  111.                             break
  112.         merge_blocks()
  113.  
  114. # 游戏循环
  115. while True:
  116.     print_board()
  117.     if is_full() and not can_move():
  118.         print("Game over!")
  119.         break
  120.     move = input("Enter move (w/a/s/d): ")
  121.     handle_move(move)
  122.     spawn_block()

在这个游戏中，玩家可以通过键盘输入 w/a/s/d 来移动数字块，合并相同的数字块，最终得到一个 $2048$ 的方块。游戏循环会一直运行，直到方格被填满且无法再移动，此时游戏结束。

扫雷

  1. import random
  2.  
  3. # 定义方格的大小
  4. n = 10
  5. m = 10
  6.  
  7. # 定义地雷数量
  8. num_mines = 10
  9.  
  10. # 初始化方格
  11. board = [[0 for x in range(m)] for y in range(n)]
  12.  
  13. # 随机生成地雷位置
  14. def place_mines(num_mines):
  15.     for i in range(num_mines):
  16.         row = random.randint(0, n - 1)
  17.         col = random.randint(0, m - 1)
  18.         while board[row][col] == -1:
  19.             row = random.randint(0, n - 1)
  20.             col = random.randint(0, m - 1)
  21.         board[row][col] = -1
  22.  
  23. # 统计地雷数量
  24. def count_mines(row, col):
  25.     count = 0
  26.     for i in range(max(row - 1, 0), min(row + 2, n)):
  27.         for j in range(max(col - 1, 0), min(col + 2, m)):
  28.             if board[i][j] == -1:
  29.                 count += 1
  30.     return count
  31.  
  32. # 显示方格
  33. def print_board():
  34.     for row in board:
  35.         for cell in row:
  36.             if cell == -1:
  37.                 print('*', end=' ')
  38.             elif cell == 0:
  39.                 print('.', end=' ')
  40.             else:
  41.                 print(cell, end=' ')
  42.         print()
  43.  
  44. # 处理玩家的选择
  45. def handle_choice(row, col):
  46.     if board[row][col] == -1:
  47.         return False
  48.     board[row][col] = count_mines(row, col)
  49.     if board[row][col] == 0:
  50.         for i in range(max(row - 1, 0), min(row + 2, n)):
  51.             for j in range(max(col - 1, 0), min(col + 2, m)):
  52.                 if board[i][j] == 0:
  53.                     handle_choice(i, j)
  54.     return True
  55.  
  56. # 游戏循环
  57. place_mines(num_mines)
  58. while True:
  59.     print_board()
  60.     if all(all(cell != 0 for cell in row) for row in board):
  61.         print("You win!")
  62.         break
  63.     row = int(input("Enter row: "))
  64.     col = int(input("Enter col: "))
  65.     if not handle_choice(row, col):
  66.         print("You lose!")
  67.         break

在这个游戏中，玩家需要在一个 $n\times m$ 的方格中找出所有的地雷，而不触雷。游戏开始时，地雷的位置会被随机生成。玩家通过输入行和列的位置来选择方块，如果选择到的方块是一个地雷，游戏结束，否则会显示该方块周围的地雷数量，并递归地展开周围的方块。如果所有不是地雷的方块都被展开，游戏结束，玩家获胜。

石头剪刀布

  1. # 定义手势
  2. HAND_GESTURES = ['rock', 'paper', 'scissors']
  3.  
  4. # 定义胜利关系
  5. WIN_CONDITIONS = {
  6.     'rock': 'scissors',
  7.     'paper': 'rock',
  8.     'scissors': 'paper'
  9. }
  10.  
  11. # 定义玩家类
  12. class Player:
  13.     def __init__(self, name):
  14.         self.name = name
  15.         self.score = 0
  16.  
  17.     # 玩家出拳
  18.     def play(self):
  19.         while True:
  20.             gesture = input(f'{self.name}, please enter your gesture (rock/paper/scissors): ')
  21.             if gesture in HAND_GESTURES:
  22.                 return gesture
  23.             else:
  24.                 print('Invalid input, please try again.')
  25.  
  26.     # 玩家获胜
  27.     def win(self):
  28.         self.score += 1
  29.         print(f'{self.name} wins!')
  30.  
  31.     # 玩家平局
  32.     def tie(self):
  33.         print("It's a tie!")
  34.  
  35.     # 玩家失败
  36.     def lose(self):
  37.         print(f'{self.name} loses!')
  38.  
  39. # 定义游戏类
  40. class Game:
  41.     def __init__(self, player1, player2):
  42.         self.player1 = player1
  43.         self.player2 = player2
  44.  
  45.     # 开始游戏
  46.     def start(self):
  47.         while True:
  48.             gesture1 = self.player1.play()
  49.             gesture2 = self.player2.play()
  50.             if gesture1 == gesture2:
  51.                 self.player1.tie()
  52.                 self.player2.tie()
  53.             elif WIN_CONDITIONS[gesture1] == gesture2:
  54.                 self.player1.win()
  55.                 self.player2.lose()
  56.             else:
  57.                 self.player1.lose()
  58.                 self.player2.win()
  59.             print(f'{self.player1.name}: {self.player1.score}, {self.player2.name}: {self.player2.score}')
  60.             if input('Do you want to play again? (y/n)') != 'y':
  61.                 break
  62.  
  63. # 创建玩家并开始游戏
  64. player1 = Player('Player 1')
  65. player2 = Player('Player 2')
  66. game = Game(player1, player2)
  67. game.start()

在这个游戏中，两个玩家通过输入手势来比拼胜负，如果两个玩家出的手势相同，则为平局；否则根据胜利关系判断胜负。游戏循环会一直运行，直到玩家选择不再继续游戏。每个玩家都有一个积分，每次胜利可以获得一分，游戏结束时积分高的玩家获胜。

飞机大战

  1. import pygame
  2. import random
  3.  
  4. # 定义窗口的大小
  5. WINDOW_WIDTH = 480
  6. WINDOW_HEIGHT = 600
  7.  
  8. # 初始化 Pygame
  9. pygame.init()
  10.  
  11. # 创建窗口
  12. window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
  13. pygame.display.set_caption('Plane Fight')
  14.  
  15. # 加载图片
  16. background_image = pygame.image.load('background.png')
  17. player_image = pygame.image.load('player.png')
  18. enemy_image = pygame.image.load('enemy.png')
  19. bullet_image = pygame.image.load('bullet.png')
  20.  
  21. # 定义颜色
  22. BLACK = (0, 0, 0)
  23. WHITE = (255, 255, 255)
  24. RED = (255, 0, 0)
  25.  
  26. # 定义字体
  27. font = pygame.font.Font(None, 36)
  28.  
  29. # 定义玩家类
  30. class Player(pygame.sprite.Sprite):
  31.     def __init__(self):
  32.         super().__init__()
  33.         self.image = player_image
  34.         self.rect = self.image.get_rect()
  35.         self.rect.centerx = WINDOW_WIDTH // 2
  36.         self.rect.bottom = WINDOW_HEIGHT - 10
  37.         self.speed = 5
  38.  
  39.     # 移动
  40.     def move(self, direction):
  41.         if direction == 'left':
  42.             self.rect.x -= self.speed
  43.         elif direction == 'right':
  44.             self.rect.x += self.speed
  45.         if self.rect.left < 0:
  46.             self.rect.left = 0
  47.         elif self.rect.right > WINDOW_WIDTH:
  48.             self.rect.right = WINDOW_WIDTH
  49.  
  50.     # 射击
  51.     def shoot(self):
  52.         bullet = Bullet(self.rect.centerx, self.rect.top)
  53.         all_sprites.add(bullet)
  54.         bullets.add(bullet)
  55.  
  56. # 定义敌机类
  57. class Enemy(pygame.sprite.Sprite):
  58.     def __init__(self):
  59.         super().__init__()
  60.         self.image = enemy_image
  61.         self.rect = self.image.get_rect()
  62.         self.rect.x = random.randint(0, WINDOW_WIDTH - self.rect.width)
  63.         self.rect.y = random.randint(-100, -self.rect.height)
  64.         self.speed = random.randint(1, 5)
  65.  
  66.     # 移动
  67.     def move(self):
  68.         self.rect.y += self.speed
  69.         if self.rect.top > WINDOW_HEIGHT:
  70.             self.kill()
  71.  
  72. # 定义子弹类
  73. class Bullet(pygame.sprite.Sprite):
  74.     def __init__(self, x, y):
  75.         super().__init__()
  76.         self.image = bullet_image
  77.         self.rect = self.image.get_rect()
  78.         self.rect.centerx = x
  79.         self.rect.bottom = y
  80.         self.speed = -10
  81.  
  82.     # 移动
  83.     def move(self):
  84.         self.rect.y += self.speed
  85.         if self.rect.bottom < 0:
  86.             self.kill()
  87.  
  88. # 创建精灵组
  89. all_sprites = pygame.sprite.Group()
  90. enemies = pygame.sprite.Group()
  91. bullets = pygame.sprite.Group()
  92.  
  93. # 创建玩家并添加到精灵组
  94. player = Player()
  95. all_sprites.add(player)
  96.  
  97. # 定义游戏循环
  98. clock = pygame.time.Clock()
  99. score = 0
  100. game_over = False
  101. while not game_over:
  102.     # 处理事件
  103.     for event in pygame.event.get():
  104.         if event.type == pygame.QUIT:
  105.             game_over = True
  106.         elif event.type == pygame.KEYDOWN:
  107.             if event.key == pygame.K_LEFT:
  108.                 player.move('left')
  109.             elif event.key == pygame.K_RIGHT:
  110.                 player.move('right')
  111.             elif event.key == pygame.K_SPACE:
  112.                 player.shoot()
  113.  
  114.     # 更新游戏状态
  115.     all_sprites.update()
  116.  
  117.     # 生成敌机
  118.     if len(enemies) < 10:
  119.         enemy = Enemy()
  120.         all_sprites.add(enemy)
  121.         enemies.add(enemy)
  122.  
  123.     # 检测子弹是否击中敌机
  124.     hits = pygame.sprite.groupcollide(enemies, bullets, True, True)
  125.     for hit in hits:
  126.         score += 10
  127.         enemy = Enemy()
  128.         all_sprites.add(enemy)
  129.         enemies.add(enemy)
  130.  
  131.     # 检测敌机是否撞击玩家
  132.     hits = pygame.sprite.spritecollide(player, enemies, False)
  133.     if len(hits) > 0:
  134.         game_over = True
  135.  
  136.     # 清屏
  137.     window.fill(BLACK)
  138.  
  139.     # 绘制背景
  140.     window.blit(background_image, (0, 0))
  141.  
  142.     # 绘制精灵组中的所有元素
  143.     all_sprites.draw(window)
  144.  
  145.     # 显示得分
  146.     score_text = font.render(f'Score: {score}', True, WHITE)
  147.     window.blit(score_text, (10, 10))
  148.  
  149.     # 更新屏幕
  150.     pygame.display.flip()
  151.  
  152.     # 控制帧率
  153.     clock.tick(60)
  154.  
  155. # 游戏结束，显示最终得分
  156. game_over_text = font.render('Game Over', True, RED)
  157. score_text = font.render(f'Final Score: {score}', True, WHITE)
  158. window.blit(game_over_text, (WINDOW_WIDTH // 2 - game_over_text.get_width() // 2, WINDOW_HEIGHT // 2 - game_over_text.get_height() // 2 - 30))
  159. window.blit(score_text, (WINDOW_WIDTH // 2 - score_text.get_width() // 2, WINDOW_HEIGHT // 2 - score_text.get_height() // 2 + 30))
  160. pygame.display.flip()
  161.  
  162. # 等待 3 秒后关闭窗口
  163. pygame.time.wait(3000)
  164. pygame.quit()

在这个游戏中，玩家需要控制飞机躲避敌机的攻击并射击敌机。玩家可以使用左右箭头键来移动飞机，使用空格键发射子弹。游戏中会随机生成敌机，玩家需要尽可能地消灭敌机并获得得分。如果敌机撞击到玩家飞机，游戏结束。

贪吃蛇

  1. import pygame
  2. import random
  3.  
  4. # 定义窗口的大小和方格的大小
  5. WINDOW_WIDTH = 480
  6. WINDOW_HEIGHT = 480
  7. CELL_SIZE = 20
  8.  
  9. # 初始化 Pygame
  10. pygame.init()
  11.  
  12. # 创建窗口
  13. window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
  14. pygame.display.set_caption('Snake')
  15.  
  16. # 定义颜色
  17. BLACK = (0, 0, 0)
  18. WHITE = (255, 255, 255)
  19. GREEN = (0, 255, 0)
  20. RED = (255, 0, 0)
  21.  
  22. # 定义字体
  23. font = pygame.font.Font(None, 36)
  24.  
  25. # 定义蛇类
  26. class Snake:
  27.     def __init__(self):
  28.         self.body = [(5, 5), (4, 5), (3, 5)]
  29.         self.direction = 'right'
  30.  
  31.     # 移动
  32.     def move(self):
  33.         head = self.body[0]
  34.         if self.direction == 'up':
  35.             new_head = (head[0], head[1] - 1)
  36.         elif self.direction == 'down':
  37.             new_head = (head[0], head[1] + 1)
  38.         elif self.direction == 'left':
  39.             new_head = (head[0] - 1, head[1])
  40.         elif self.direction == 'right':
  41.             new_head = (head[0] + 1, head[1])
  42.         self.body.insert(0, new_head)
  43.         self.body.pop()
  44.  
  45.     # 改变方向
  46.     def change_direction(self, direction):
  47.         if direction == 'up' and self.direction != 'down':
  48.             self.direction = 'up'
  49.         elif direction == 'down' and self.direction != 'up':
  50.             self.direction = 'down'
  51.         elif direction == 'left' and self.direction != 'right':
  52.             self.direction = 'left'
  53.         elif direction == 'right' and self.direction != 'left':
  54.             self.direction = 'right'
  55.  
  56.     # 检查是否吃到食物
  57.     def check_eat_food(self, food):
  58.         if self.body[0] == food.position:
  59.             self.body.append(self.body[-1])
  60.  
  61. # 定义食物类
  62. class Food:
  63.     def __init__(self):
  64.         self.position = (random.randint(0, WINDOW_WIDTH // CELL_SIZE - 1), random.randint(0, WINDOW_HEIGHT // CELL_SIZE - 1))
  65.  
  66.     # 重新生成位置
  67.     def respawn(self):
  68.         self.position = (random.randint(0, WINDOW_WIDTH // CELL_SIZE - 1), random.randint(0, WINDOW_HEIGHT // CELL_SIZE - 1))
  69.  
  70. # 创建蛇和食物对象
  71. snake = Snake()
  72. food = Food()
  73.  
  74. # 定义游戏循环
  75. clock = pygame.time.Clock()
  76. score = 0
  77. game_over = False
  78. while not game_over:
  79.     # 处理事件
  80.     for event in pygame.event.get():
  81.         if event.type == pygame.QUIT:
  82.             game_over = True
  83.         elif event.type == pygame.KEYDOWN:
  84.             if event.key == pygame.K_UP:
  85.                 snake.change_direction('up')
  86.             elif event.key == pygame.K_DOWN:
  87.                 snake.change_direction('down')
  88.             elif event.key == pygame.K_LEFT:
  89.                 snake.change_direction('left')
  90.             elif event.key == pygame.K_RIGHT:
  91.                 snake.change_direction('right')
  92.  
  93.     # 更新游戏状态
  94.     snake.move()
  95.     snake.check_eat_food(food)
  96.     if snake.body[0][0] < 0 or snake.body[0][0] >= WINDOW_WIDTH // CELL_SIZE or snake.body[0][1] < 0 or snake.body[0][1] >= WINDOW_HEIGHT // CELL_SIZE:
  97.         game_over = True
  98.     for i in range(1, len(snake.body)):
  99.         if snake.body[i] == snake.body[0]:
  100.             game_over = True
  101.  
  102.     # 清屏
  103.     window.fill(BLACK)
  104.  
  105.     # 绘制蛇
  106.     for cell in snake.body:
  107.         pygame.draw.rect(window, GREEN, (cell[0] * CELL_SIZE, cell[1] * CELL_SIZE, CELL_SIZE, CELL_SIZE))
  108.  
  109.     # 绘制食物
  110.     pygame.draw.rect(window, RED, (food.position[0] * CELL_SIZE, food.position[1] * CELL_SIZE, CELL_SIZE, CELL_SIZE))
  111.  
  112.     # 显示得分希望这个示例能够帮助您更好地了解 Python 编程语言。如果您有任何问题，请随时问我。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/84759
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号