设为首页收藏本站
首页 > 论坛 > 行空板

[M10项目]行空板+空中飞鼠键盘 飞机大战 精华

云天 | 中级技神 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2023-9-17 13:19:57 [显示全部楼层]
5594浏览
5回复
1收藏
查看: 5594|回复: 5

[M10项目] 行空板+空中飞鼠键盘 飞机大战

[复制链接]
本帖最后由 云天 于 2023-9-17 13:31 编辑

【项目背景】
行空板+空中飞鼠键盘 飞机大战图1


最近在DF商城上看到“空中飞鼠键盘”，它连到行空板上时，您不需安装任何驱动，只需把它插上去，就能立即使用了。它使用了2.4G无线传输技术，传输距离可达30米。无论是在客厅还是办公室，您都可使用它进行远程遥控。
【项目设计】
使用行空板结合“空中飞鼠键盘”，利用“PYgame库”，制作多个使用键盘控制的行空板小游戏。

行空板+空中飞鼠键盘 飞机大战图2

俄罗斯方块

行空板+空中飞鼠键盘 飞机大战图4

贪吃蛇


行空板+空中飞鼠键盘 飞机大战图3


飞机大战

【演示视频】


【飞机大战】

这次用Mind+软件Python模式下，连接终端行空板，利用Python中的pygame模块来完成一个飞机大战的小游戏；基本思路是通过方向键来控制飞机的左右移动射击飞船。
创建一个可以左右移动的小飞机，用户可以通过空格space键来控制飞机发射子弹
1.创建背景，加载角色
  1. import pygame

  2. import random

  3. import time

  4. # 定义窗口的大小

  5. WINDOW_WIDTH = 240

  6. WINDOW_HEIGHT = 320

  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)

复制代码

2.主循环体中，实现键盘控制
  1. 

  2. while not game_over:

  3.     # 处理事件

  4.     for event in pygame.event.get():

  5.         if event.type == pygame.QUIT:

  6.             game_over = True

  7.         

  8.         elif event.type == pygame.KEYDOWN:

  9.             if event.key == pygame.K_RIGHT:

  10.                 # 当用户按下键位时标志位为True

  11.                 player.mv_right = True

  12.             elif event.key == pygame.K_LEFT:

  13.                 player.mv_left = True

  14.             if event.key == pygame.K_SPACE:#用户按下空格之后会创建一个子弹

  15.                

  16.                    player.mv_shoot = True

  17.                 

  18. 

  19.         elif event.type == pygame.KEYUP:

  20.             if event.key == pygame.K_RIGHT:

  21.                 # 当用户松开键位为false

  22.                 player.mv_right = False

  23.             elif event.key == pygame.K_LEFT:

  24.                 player.mv_left = False    

  25.             if event.key == pygame.K_SPACE:

  26.                 

  27.                 player.mv_shoot = False 

  28.             

复制代码

3.绘制小飞机玩家

定义一个Player类，来存储飞机的各种行为。
  1. 

  2. # 定义玩家类

  3. class Player(pygame.sprite.Sprite):

  4.     def __init__(self):

  5.         super().__init__()

  6. 

  7.         self.image = player_image

  8.         self.rect = self.image.get_rect()

  9.         self.rect.centerx = WINDOW_WIDTH // 2

  10.         self.rect.bottom = WINDOW_HEIGHT - 10

  11.         self.speed = 5

  12.         self.mv_right = False

  13.         self.mv_left = False

  14.         self.mv_shoot= False

  15.         self.Bullet_num=10

  16.         self.shoot_speed=1

  17.         self.last_shoot_time=time.time()

  18.     # 移动

  19.     # 定义一个调整小飞机位置的方法

  20.     def update(self):

  21.         # 根据标志位的调整小飞机的位置

  22.         #实现左右移动，控制小飞机持续移动

  23.         if self.mv_right:

  24.             self.rect.centerx += self.speed

  25.         if self.mv_left:

  26.             self.rect.centerx -= self.speed

  27.         if self.rect.left < 0:

  28.             self.rect.left = 0

  29.         elif self.rect.right > WINDOW_WIDTH:#限制小飞机的活动范围

  30.             self.rect.right = WINDOW_WIDTH

  31.         if self.mv_shoot:

  32.                 curTime_shoot = time.time()

  33.                 if curTime_shoot-self.last_shoot_time>self.shoot_speed:#限制子弹发射频率

  34.                    self.last_shoot_time = time.time()

  35.                    player.shoot()

  36.     # 射击

  37.     def shoot(self):

  38.         bullet = Bullet(self.rect.centerx, self.rect.top)

  39.         all_sprites.add(bullet)

  40.         bullets.add(bullet)

复制代码
  1. 

  2. # 创建精灵组

  3. all_sprites = pygame.sprite.Group()

  4. enemies = pygame.sprite.Group()

  5. bullets = pygame.sprite.Group()

  6.  

  7. # 创建玩家并添加到精灵组

  8. player = Player()

  9. all_sprites.add(player)

复制代码

4.完成射击功能
通过玩家按下空格来发射子弹
  1. 

  2. # 定义子弹类

  3. class Bullet(pygame.sprite.Sprite):

  4.     def __init__(self, x, y):

  5.         super().__init__()

  6.         self.image = bullet_image

  7.         self.rect = self.image.get_rect()

  8.         self.rect.centerx = x

  9.         self.rect.bottom = y

  10.         self.speed = -10

  11.  

  12.     # 移动

  13.     def update(self):

  14.         self.rect.y += self.speed

  15.         if self.rect.bottom < 0:#删除已经消失的子弹

  16.             self.kill()

复制代码

5.制作飞船
现在小飞机也创建完成了，现在就该创建小飞机的敌人了，同样通过一个类来控制其所有行为。

  1. 

  2. # 定义敌机类

  3. class Enemy(pygame.sprite.Sprite):

  4.     def __init__(self):

  5.         super().__init__()

  6.         self.image = enemy_image

  7.         self.rect = self.image.get_rect()

  8.         self.rect.x = random.randint(0, WINDOW_WIDTH - self.rect.width)

  9.         self.rect.y = random.randint(-100, -self.rect.height)

  10.         self.speed = random.randint(1, 2)

  11.  

  12.     # 移动

  13.     def update(self):

  14.         self.rect.y += self.speed

  15.         if self.rect.top > WINDOW_HEIGHT:

  16.             self.kill()

  17.  

复制代码

玩家小飞机可以射杀飞船、当飞船碰到小飞机GAMEOVER，飞船碰到地面也GAMEOVER

  1. 

  2.     # 生成敌机

  3.     curTime = time.time()

  4.      

  5.     if len(enemies) < 10 and curTime - last_move_time>random.randint(3,enemy_speed+3):

  6.         print(enemy_speed)

  7.         last_move_time=time.time()

  8.         enemy = Enemy()

  9.         all_sprites.add(enemy)

  10.         enemies.add(enemy)

  11.  

  12.     # 检测子弹是否击中敌机

  13.     hits = pygame.sprite.groupcollide(enemies, bullets, True, True)

  14.     for hit in hits:

  15.         score += 10

  16.     #随得分增加，加大敌机生成频率和生成子弹频率

  17.     if score<1000:

  18.       enemy_speed=10-int(score/100)

  19.       player.shoot_speed=1-int(score/100)/10

  20.     else:

  21.       enemy_speed=1

  22.       player.shoot_speed=0.1

  23.     # 检测敌机是否撞击玩家

  24.     hits = pygame.sprite.spritecollide(player, enemies, False)

  25.     if len(hits) > 0:

  26.         game_over = True

复制代码
6.更新角色游戏状态

  1. 

  2.     # 更新游戏状态

  3.     all_sprites.update()

  4.     # 清屏

  5.     window.fill(BLACK)

  6.  

  7.     # 绘制背景

  8.     window.blit(background_image, (0, 0))

  9.  

  10.     # 绘制精灵组中的所有元素

  11.     all_sprites.draw(window)

  12.  

  13.     # 显示得分

  14.     score_text = font.render(f'Score: {score}', True, WHITE)

  15.     window.blit(score_text, (10, 10))

  16.     

  17.     # 更新屏幕

  18.     pygame.display.flip()

  19.  

  20.     # 控制帧率

  21.     clock.tick(60)

复制代码
7.游戏结束
  1. 

  2.  

  3. # 游戏结束，显示最终得分

  4. game_over_text = font.render('Game Over', True, RED)

  5. score_text = font.render(f'Final Score: {score}', True, WHITE)

  6. window.blit(game_over_text, (WINDOW_WIDTH // 2 - game_over_text.get_width() // 2, WINDOW_HEIGHT // 2 - game_over_text.get_height() // 2 - 30))

  7. window.blit(score_text, (WINDOW_WIDTH // 2 - score_text.get_width() // 2, WINDOW_HEIGHT // 2 - score_text.get_height() // 2 + 30))

  8. pygame.display.flip()

  9.  

  10. # 等待 10 秒后关闭窗口

  11. pygame.time.wait(10000)

  12. pygame.quit()

复制代码

8.完整代码
  1. 

  2. 

  3. import pygame

  4. import random

  5. import time

  6. # 定义窗口的大小

  7. WINDOW_WIDTH = 240

  8. WINDOW_HEIGHT = 320

  9.  

  10. # 初始化 Pygame

  11. pygame.init()

  12.  

  13. # 创建窗口 设置屏幕的分辨率

  14. window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))

  15. pygame.display.set_caption('Plane Fight')

  16.  

  17. # 加载角色图片

  18. background_image = pygame.image.load('background.png')

  19. player_image = pygame.image.load('player.png')

  20. enemy_image = pygame.image.load('enemy.png')

  21. bullet_image = pygame.image.load('bullet.png')

  22.  

  23. # 定义颜色

  24. BLACK = (0, 0, 0)

  25. WHITE = (255, 255, 255)

  26. RED = (255, 0, 0)

  27.  

  28. # 定义字体

  29. font = pygame.font.Font(None, 36)

  30. 

  31. # 定义玩家类

  32. class Player(pygame.sprite.Sprite):

  33.     def __init__(self):

  34.         super().__init__()

  35. 

  36.         self.image = player_image

  37.         self.rect = self.image.get_rect()

  38.         self.rect.centerx = WINDOW_WIDTH // 2

  39.         self.rect.bottom = WINDOW_HEIGHT - 10

  40.         self.speed = 5

  41.         self.mv_right = False

  42.         self.mv_left = False

  43.         self.mv_shoot= False

  44.         self.Bullet_num=10

  45.         self.shoot_speed=1

  46.         self.last_shoot_time=time.time()

  47.     # 移动

  48.     # 定义一个调整小飞机位置的方法

  49.     def update(self):

  50.         # 根据标志位的调整小飞机的位置

  51.         

  52.         if self.mv_right:

  53.             self.rect.centerx += self.speed

  54.         if self.mv_left:

  55.             self.rect.centerx -= self.speed

  56.         if self.rect.left < 0:

  57.             self.rect.left = 0

  58.         elif self.rect.right > WINDOW_WIDTH:

  59.             self.rect.right = WINDOW_WIDTH

  60.         if self.mv_shoot:

  61.                 curTime_shoot = time.time()

  62.                 if curTime_shoot-self.last_shoot_time>self.shoot_speed:

  63.                    self.last_shoot_time = time.time()

  64.                    player.shoot()

  65.     # 射击

  66.     def shoot(self):

  67.         bullet = Bullet(self.rect.centerx, self.rect.top)

  68.         all_sprites.add(bullet)

  69.         bullets.add(bullet)

  70.  

  71. # 定义敌机类

  72. class Enemy(pygame.sprite.Sprite):

  73.     def __init__(self):

  74.         super().__init__()

  75.         self.image = enemy_image

  76.         self.rect = self.image.get_rect()

  77.         self.rect.x = random.randint(0, WINDOW_WIDTH - self.rect.width)

  78.         self.rect.y = random.randint(-100, -self.rect.height)

  79.         self.speed = random.randint(1, 2)

  80.  

  81.     # 移动

  82.     def update(self):

  83.         self.rect.y += self.speed

  84.         if self.rect.top > WINDOW_HEIGHT:

  85.             self.kill()

  86.  

  87. # 定义子弹类

  88. class Bullet(pygame.sprite.Sprite):

  89.     def __init__(self, x, y):

  90.         super().__init__()

  91.         self.image = bullet_image

  92.         self.rect = self.image.get_rect()

  93.         self.rect.centerx = x

  94.         self.rect.bottom = y

  95.         self.speed = -10

  96.  

  97.     # 移动

  98.     def update(self):

  99.         self.rect.y += self.speed

  100.         if self.rect.bottom < 0:

  101.             self.kill()

  102.     

  103. # 创建精灵组

  104. all_sprites = pygame.sprite.Group()

  105. enemies = pygame.sprite.Group()

  106. bullets = pygame.sprite.Group()

  107.  

  108. # 创建玩家并添加到精灵组

  109. player = Player()

  110. all_sprites.add(player)

  111.  

  112. # 定义游戏循环

  113. clock = pygame.time.Clock()

  114. score = 0

  115. game_over = False

  116. last_move_time=time.time()

  117. 

  118. enemy_speed=10

  119. while not game_over:

  120.     # 处理事件

  121.     for event in pygame.event.get():

  122.         if event.type == pygame.QUIT:

  123.             game_over = True

  124.         

  125.         elif event.type == pygame.KEYDOWN:

  126.             if event.key == pygame.K_RIGHT:

  127.                 # 当用户按下键位时标志位为True

  128.                 player.mv_right = True

  129.             elif event.key == pygame.K_LEFT:

  130.                 player.mv_left = True

  131.             if event.key == pygame.K_SPACE:

  132.                

  133.                    player.mv_shoot = True

  134.                 

  135. 

  136.         elif event.type == pygame.KEYUP:

  137.             if event.key == pygame.K_RIGHT:

  138.                 # 当用户松开键位为false

  139.                 player.mv_right = False

  140.             elif event.key == pygame.K_LEFT:

  141.                 player.mv_left = False    

  142.             if event.key == pygame.K_SPACE:

  143.                 

  144.                 player.mv_shoot = False 

  145.             

  146.  

  147.     # 更新游戏状态

  148.     all_sprites.update()

  149.     

  150.     # 生成敌机

  151.     curTime = time.time()

  152.      

  153.     if len(enemies) < 10 and curTime - last_move_time>random.randint(3,enemy_speed+3):

  154.         print(enemy_speed)

  155.         last_move_time=time.time()

  156.         enemy = Enemy()

  157.         all_sprites.add(enemy)

  158.         enemies.add(enemy)

  159.  

  160.     # 检测子弹是否击中敌机

  161.     hits = pygame.sprite.groupcollide(enemies, bullets, True, True)

  162.     for hit in hits:

  163.         score += 10

  164.     #随得分增加，加大敌机生成频率和生成子弹频率

  165.     if score<1000:

  166.       enemy_speed=10-int(score/100)

  167.       player.shoot_speed=1-int(score/100)/10

  168.     else:

  169.       enemy_speed=1

  170.       player.shoot_speed=0.1

  171.     # 检测敌机是否撞击玩家

  172.     hits = pygame.sprite.spritecollide(player, enemies, False)

  173.     if len(hits) > 0:

  174.         game_over = True

  175.  

  176.     # 清屏

  177.     window.fill(BLACK)

  178.  

  179.     # 绘制背景

  180.     window.blit(background_image, (0, 0))

  181.  

  182.     # 绘制精灵组中的所有元素

  183.     all_sprites.draw(window)

  184.  

  185.     # 显示得分

  186.     score_text = font.render(f'Score: {score}', True, WHITE)

  187.     window.blit(score_text, (10, 10))

  188.     

  189.     # 更新屏幕

  190.     pygame.display.flip()

  191.  

  192.     # 控制帧率

  193.     clock.tick(60)

  194.  

  195. # 游戏结束，显示最终得分

  196. game_over_text = font.render('Game Over', True, RED)

  197. score_text = font.render(f'Final Score: {score}', True, WHITE)

  198. window.blit(game_over_text, (WINDOW_WIDTH // 2 - game_over_text.get_width() // 2, WINDOW_HEIGHT // 2 - game_over_text.get_height() // 2 - 30))

  199. window.blit(score_text, (WINDOW_WIDTH // 2 - score_text.get_width() // 2, WINDOW_HEIGHT // 2 - score_text.get_height() // 2 + 30))

  200. pygame.display.flip()

  201.  

  202. # 等待 3 秒后关闭窗口

  203. pygame.time.wait(10000)

  204. pygame.quit()

  205. 

复制代码

【俄罗斯方块】
  1. 

  2. import sys

  3. import time

  4. import pygame

  5. from pygame.locals import *

  6. import blocks

  7. 

  8. SIZE = 10  # 每个小方格大小

  9. BLOCK_HEIGHT = 32  # 游戏区高度

  10. BLOCK_WIDTH = 20   # 游戏区宽度

  11. BORDER_WIDTH = 4   # 游戏区边框宽度

  12. BORDER_COLOR = (40, 40, 200)  # 游戏区边框颜色

  13. SCREEN_WIDTH = SIZE * (BLOCK_WIDTH + 4)  # 游戏屏幕的宽

  14. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT      # 游戏屏幕的高

  15. BG_COLOR = (40, 40, 60)  # 背景色

  16. BLOCK_COLOR = (20, 128, 200)  #

  17. BLACK = (0, 0, 0)

  18. RED = (200, 30, 30)      # GAME OVER 的字体颜色

  19. 

  20. 

  21. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):

  22.   imgText = font.render(text, True, fcolor)

  23.   screen.blit(imgText, (x, y))

  24. 

  25. 

  26. def main():

  27.   pygame.init()

  28.   screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

  29.   pygame.display.set_caption('俄罗斯方块')

  30. 

  31.   font1 = pygame.font.SysFont('SimHei', 14)  # 黑体24

  32.   font2 = pygame.font.Font(None, 55)  # GAME OVER 的字体

  33.   font_pos_x = BLOCK_WIDTH * SIZE + BORDER_WIDTH + 2  # 右侧信息显示区域字体位置的X坐标

  34.   gameover_size = font2.size('GAME OVER')

  35.   font1_height = int(font1.size('score')[1])

  36. 

  37.   cur_block = None   # 当前下落方块

  38.   next_block = None  # 下一个方块

  39.   cur_pos_x, cur_pos_y = 0, 0

  40. 

  41.   game_area = None    # 整个游戏区域

  42.   game_over = True

  43.   start = False       # 是否开始，当start = True，game_over = True 时，才显示 GAME OVER

  44.   score = 0           # 得分

  45.   orispeed = 0.5      # 原始速度

  46.   speed = orispeed    # 当前速度

  47.   pause = False       # 暂停

  48.   last_drop_time = None   # 上次下落时间

  49.   last_press_time = None  # 上次按键时间

  50. 

  51.   def _dock():

  52.       nonlocal cur_block, next_block, game_area, cur_pos_x, cur_pos_y, game_over, score, speed

  53.       for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):

  54.           for _j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):

  55.               if cur_block.template[_i][_j] != '.':

  56.                   game_area[cur_pos_y + _i][cur_pos_x + _j] = '0'

  57.       if cur_pos_y + cur_block.start_pos.Y <= 0:

  58.           game_over = True

  59.       else:

  60.           # 计算消除

  61.           remove_idxs = []

  62.           for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):

  63.               if all(_x == '0' for _x in game_area[cur_pos_y + _i]):

  64.                   remove_idxs.append(cur_pos_y + _i)

  65.           if remove_idxs:

  66.               # 计算得分

  67.               remove_count = len(remove_idxs)

  68.               if remove_count == 1:

  69.                   score += 100

  70.               elif remove_count == 2:

  71.                   score += 300

  72.               elif remove_count == 3:

  73.                   score += 700

  74.               elif remove_count == 4:

  75.                   score += 1500

  76.               speed = orispeed - 0.03 * (score // 10000)

  77.               # 消除

  78.               _i = _j = remove_idxs[-1]

  79.               while _i >= 0:

  80.                   while _j in remove_idxs:

  81.                       _j -= 1

  82.                   if _j < 0:

  83.                       game_area[_i] = ['.'] * BLOCK_WIDTH

  84.                   else:

  85.                       game_area[_i] = game_area[_j]

  86.                   _i -= 1

  87.                   _j -= 1

  88.           cur_block = next_block

  89.           next_block = blocks.get_block()

  90.           cur_pos_x, cur_pos_y = (BLOCK_WIDTH - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y

  91. 

  92.   def _judge(pos_x, pos_y, block):

  93.       nonlocal game_area

  94.       for _i in range(block.start_pos.Y, block.end_pos.Y + 1):

  95.           if pos_y + block.end_pos.Y >= BLOCK_HEIGHT:

  96.               return False

  97.           for _j in range(block.start_pos.X, block.end_pos.X + 1):

  98.               if pos_y + _i >= 0 and block.template[_i][_j] != '.' and game_area[pos_y + _i][pos_x + _j] != '.':

  99.                   return False

  100.       return True

  101. 

  102.   while True:

  103.       for event in pygame.event.get():

  104.           if event.type == QUIT:

  105.               sys.exit()

  106.           elif event.type == KEYDOWN:

  107.               if event.key == K_RETURN:

  108.                   if game_over:

  109.                       start = True

  110.                       game_over = False

  111.                       score = 0

  112.                       last_drop_time = time.time()

  113.                       last_press_time = time.time()

  114.                       game_area = [['.'] * BLOCK_WIDTH for _ in range(BLOCK_HEIGHT)]

  115.                       cur_block = blocks.get_block()

  116.                       next_block = blocks.get_block()

  117.                       cur_pos_x, cur_pos_y = (BLOCK_WIDTH - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y

  118.               elif event.key == K_SPACE:

  119.                   if not game_over:

  120.                       pause = not pause

  121.               elif event.key in (K_w, K_UP):

  122. 

  123.                   if 0 <= cur_pos_x <= BLOCK_WIDTH - len(cur_block.template[0]):

  124.                       _next_block = blocks.get_next_block(cur_block)

  125.                       if _judge(cur_pos_x, cur_pos_y, _next_block):

  126.                           cur_block = _next_block

  127.               elif event.key in (K_a, K_LEFT):

  128.                       if time.time() - last_press_time > 0.1:

  129.                         last_press_time = time.time()

  130.                         if cur_pos_x > - cur_block.start_pos.X:

  131.                           if _judge(cur_pos_x - 1, cur_pos_y, cur_block):

  132.                               cur_pos_x -= 1

  133.               elif event.key in (K_d, K_RIGHT):

  134.                       if time.time() - last_press_time > 0.1:

  135.                         last_press_time = time.time()

  136.                       # 不能移除右边框

  137.                         if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH:

  138.                           if _judge(cur_pos_x + 1, cur_pos_y, cur_block):

  139.                               cur_pos_x += 1

  140.               elif event.key in (K_s, K_DOWN):

  141.                       if time.time() - last_press_time > 0.1:

  142.                         last_press_time = time.time()

  143.                         if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):

  144.                           _dock()

  145.                         else:

  146.                           last_drop_time = time.time()

  147.                           cur_pos_y += 1

  148. 

  149.       if event.type == pygame.KEYDOWN:

  150.           if event.key == pygame.K_LEFT:

  151.               if not game_over and not pause:

  152.                   if time.time() - last_press_time > 0.1:

  153.                       last_press_time = time.time()

  154.                       if cur_pos_x > - cur_block.start_pos.X:

  155.                           if _judge(cur_pos_x - 1, cur_pos_y, cur_block):

  156.                               cur_pos_x -= 1

  157.           if event.key == pygame.K_RIGHT:

  158.               if not game_over and not pause:

  159.                   if time.time() - last_press_time > 0.1:

  160.                       last_press_time = time.time()

  161.                       # 不能移除右边框

  162.                       if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH:

  163.                           if _judge(cur_pos_x + 1, cur_pos_y, cur_block):

  164.                               cur_pos_x += 1

  165.           if event.key == pygame.K_DOWN:

  166.               if not game_over and not pause:

  167.                   if time.time() - last_press_time > 0.1:

  168.                       last_press_time = time.time()

  169.                       if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):

  170.                           _dock()

  171.                       else:

  172.                           last_drop_time = time.time()

  173.                           cur_pos_y += 1

  174. 

  175.       _draw_background(screen)

  176. 

  177.       _draw_game_area(screen, game_area)

  178. 

  179.       _draw_gridlines(screen)

  180. 

  181.       _draw_info(screen, font1, font_pos_x, font1_height, score)

  182.       # 画显示信息中的下一个方块

  183.       _draw_block(screen, next_block, font_pos_x, 30 + (font1_height + 6) * 5, 0, 0)

  184. 

  185.       if not game_over:

  186.           cur_drop_time = time.time()

  187.           if cur_drop_time - last_drop_time > speed:

  188.               if not pause:

  189. 

  190.                   if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):

  191.                       _dock()

  192.                   else:

  193.                       last_drop_time = cur_drop_time

  194.                       cur_pos_y += 1

  195.       else:

  196.           if start:

  197.               print_text(screen, font2,

  198.                          (SCREEN_WIDTH - gameover_size[0]) // 2, (SCREEN_HEIGHT - gameover_size[1]) // 2,

  199.                          'GAME OVER', RED)

  200. 

  201.       # 画当前下落方块

  202.       _draw_block(screen, cur_block, 0, 0, cur_pos_x, cur_pos_y)

  203. 

  204.       pygame.display.flip()

  205. 

  206. 

  207. # 画背景

  208. def _draw_background(screen):

  209.   # 填充背景色

  210.   screen.fill(BG_COLOR)

  211.   # 画游戏区域分隔线

  212.   pygame.draw.line(screen, BORDER_COLOR,

  213.                    (SIZE * BLOCK_WIDTH + BORDER_WIDTH // 2, 0),

  214.                    (SIZE * BLOCK_WIDTH + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)

  215. 

  216. 

  217. # 画网格线

  218. def _draw_gridlines(screen):

  219.   # 画网格线 竖线

  220.   for x in range(BLOCK_WIDTH):

  221.       pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)

  222.   # 画网格线 横线

  223.   for y in range(BLOCK_HEIGHT):

  224.       pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH * SIZE, y * SIZE), 1)

  225. 

  226. 

  227. # 画已经落下的方块

  228. def _draw_game_area(screen, game_area):

  229.   if game_area:

  230.       for i, row in enumerate(game_area):

  231.           for j, cell in enumerate(row):

  232.               if cell != '.':

  233.                   pygame.draw.rect(screen, BLOCK_COLOR, (j * SIZE, i * SIZE, SIZE, SIZE), 0)

  234. 

  235. 

  236. # 画单个方块

  237. def _draw_block(screen, block, offset_x, offset_y, pos_x, pos_y):

  238.   if block:

  239.       for i in range(block.start_pos.Y, block.end_pos.Y + 1):

  240.           for j in range(block.start_pos.X, block.end_pos.X + 1):

  241.               if block.template[i][j] != '.':

  242.                   pygame.draw.rect(screen, BLOCK_COLOR,

  243.                                    (offset_x + (pos_x + j) * SIZE, offset_y + (pos_y + i) * SIZE, SIZE, SIZE), 0)

  244. 

  245. 

  246. # 画得分等信息

  247. def _draw_info(screen, font, pos_x, font_height, score):

  248.   print_text(screen, font, pos_x, 10, f'score: ')

  249.   print_text(screen, font, pos_x, 10 + font_height + 6, f'{score}')

  250.   print_text(screen, font, pos_x, 20 + (font_height + 6) * 2, f'speed:')

  251.   print_text(screen, font, pos_x, 20 + (font_height + 6) * 3, f'{score // 10000}')

  252.   print_text(screen, font, pos_x, 30 + (font_height + 6) * 4, f'next:')

  253. 

  254. 

  255. if __name__ == '__main__':

  256.   main()

  257. 

复制代码
【贪吃蛇】
  1. 

  2. import random

  3. import sys

  4. import time

  5. import pygame

  6. from pygame.locals import *

  7. from collections import deque

  8. 

  9. SCREEN_WIDTH = 240      # 屏幕宽度

  10. SCREEN_HEIGHT = 320     # 屏幕高度

  11. SIZE = 20               # 小方格大小

  12. LINE_WIDTH = 1          # 网格线宽度

  13. 

  14. # 游戏区域的坐标范围

  15. SCOPE_X = (0, SCREEN_WIDTH // SIZE - 1)

  16. SCOPE_Y = (2, SCREEN_HEIGHT // SIZE - 1)

  17. 

  18. # 食物的分值及颜色

  19. FOOD_STYLE_LIST = [(10, (255, 100, 100)), (20, (100, 255, 100)), (30, (100, 100, 255))]

  20. 

  21. LIGHT = (100, 100, 100)

  22. DARK = (200, 200, 200)      # 蛇的颜色

  23. BLACK = (0, 0, 0)           # 网格线颜色

  24. RED = (200, 30, 30)         # 红色，GAME OVER 的字体颜色

  25. BGCOLOR = (40, 40, 60)      # 背景色

  26. 

  27. 

  28. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):

  29.   imgText = font.render(text, True, fcolor)

  30.   screen.blit(imgText, (x, y))

  31. 

  32. 

  33. # 初始化蛇

  34. def init_snake():

  35.   snake = deque()

  36.   snake.append((2, SCOPE_Y[0]))

  37.   snake.append((1, SCOPE_Y[0]))

  38.   snake.append((0, SCOPE_Y[0]))

  39.   return snake

  40. 

  41. 

  42. def create_food(snake):

  43.   food_x = random.randint(SCOPE_X[0], SCOPE_X[1])

  44.   food_y = random.randint(SCOPE_Y[0], SCOPE_Y[1])

  45.   while (food_x, food_y) in snake:

  46.       # 如果食物出现在蛇身上，则重来

  47.       food_x = random.randint(SCOPE_X[0], SCOPE_X[1])

  48.       food_y = random.randint(SCOPE_Y[0], SCOPE_Y[1])

  49.   return food_x, food_y

  50. 

  51. 

  52. def get_food_style():

  53.   return FOOD_STYLE_LIST[random.randint(0, 2)]

  54. 

  55. 

  56. def main():

  57.   pygame.init()

  58.   screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

  59.   pygame.display.set_caption('贪吃蛇')

  60. 

  61.   font1 = pygame.font.SysFont('SimHei', 23)  # 得分的字体

  62.   font2 = pygame.font.Font(None, 55)  # GAME OVER 的字体

  63.   fwidth, fheight = font2.size('GAME OVER')

  64. 

  65.   # 如果蛇正在向右移动，那么快速点击向下向左，由于程序刷新没那么快，向下事件会被向左覆盖掉，导致蛇后退，直接GAME OVER

  66.   # b 变量就是用于防止这种情况的发生

  67.   b = True

  68. 

  69.   # 蛇

  70.   snake = init_snake()

  71.   # 食物

  72.   food = create_food(snake)

  73.   food_style = get_food_style()

  74.   # 方向

  75.   pos = (1, 0)

  76. 

  77.   game_over = True

  78.   start = False       # 是否开始，当start = True，game_over = True 时，才显示 GAME OVER

  79.   score = 0           # 得分

  80.   orispeed = 0.5      # 原始速度

  81.   speed = orispeed

  82.   last_move_time = None

  83.   pause = False       # 暂停

  84. 

  85.   while True:

  86.       for event in pygame.event.get():

  87.           if event.type == QUIT:

  88.               sys.exit()

  89.           elif event.type == KEYDOWN:

  90.               if event.key == K_RETURN:

  91.                   if game_over:

  92.                       start = True

  93.                       game_over = False

  94.                       b = True

  95.                       snake = init_snake()

  96.                       food = create_food(snake)

  97.                       food_style = get_food_style()

  98.                       pos = (1, 0)

  99.                       # 得分

  100.                       score = 0

  101.                       last_move_time = time.time()

  102.               elif event.key == K_SPACE:

  103.                   if not game_over:

  104.                       pause = not pause

  105.               elif event.key in (K_w, K_UP):

  106.                   # 这个判断是为了防止蛇向上移时按了向下键，导致直接 GAME OVER

  107.                   if b and not pos[1]:

  108.                       pos = (0, -1)

  109.                       b = False

  110.               elif event.key in (K_s, K_DOWN):

  111.                   if b and not pos[1]:

  112.                       pos = (0, 1)

  113.                       b = False

  114.               elif event.key in (K_a, K_LEFT):

  115.                   if b and not pos[0]:

  116.                       pos = (-1, 0)

  117.                       b = False

  118.               elif event.key in (K_d, K_RIGHT):

  119.                   if b and not pos[0]:

  120.                       pos = (1, 0)

  121.                       b = False

  122. 

  123.       # 填充背景色

  124.       screen.fill(BGCOLOR)

  125.       # 画网格线 竖线

  126.       for x in range(SIZE, SCREEN_WIDTH, SIZE):

  127.           pygame.draw.line(screen, BLACK, (x, SCOPE_Y[0] * SIZE), (x, SCREEN_HEIGHT), LINE_WIDTH)

  128.       # 画网格线 横线

  129.       for y in range(SCOPE_Y[0] * SIZE, SCREEN_HEIGHT, SIZE):

  130.           pygame.draw.line(screen, BLACK, (0, y), (SCREEN_WIDTH, y), LINE_WIDTH)

  131. 

  132.       if not game_over:

  133.           curTime = time.time()

  134.           if curTime - last_move_time > speed:

  135.               if not pause:

  136.                   b = True

  137.                   last_move_time = curTime

  138.                   next_s = (snake[0][0] + pos[0], snake[0][1] + pos[1])

  139.                   if next_s == food:

  140.                       # 吃到了食物

  141.                       snake.appendleft(next_s)

  142.                       score += food_style[0]

  143.                       speed = orispeed - 0.03 * (score // 100)

  144.                       food = create_food(snake)

  145.                       food_style = get_food_style()

  146.                   else:

  147.                       if SCOPE_X[0] <= next_s[0] <= SCOPE_X[1] and SCOPE_Y[0] <= next_s[1] <= SCOPE_Y[1] \

  148.                               and next_s not in snake:

  149.                           snake.appendleft(next_s)

  150.                           snake.pop()

  151.                       else:

  152.                           game_over = True

  153. 

  154.       # 画食物

  155.       if not game_over:

  156.           # 避免 GAME OVER 的时候把 GAME OVER 的字给遮住了

  157.           pygame.draw.rect(screen, food_style[1], (food[0] * SIZE, food[1] * SIZE, SIZE, SIZE), 0)

  158. 

  159.       # 画蛇

  160.       for s in snake:

  161.           pygame.draw.rect(screen, DARK, (s[0] * SIZE + LINE_WIDTH, s[1] * SIZE + LINE_WIDTH,

  162.                                           SIZE - LINE_WIDTH * 2, SIZE - LINE_WIDTH * 2), 0)

  163. 

  164.       print_text(screen, font1, 5, 10, f'speed: {score//100}')

  165.       print_text(screen, font1, 105, 10, f'score: {score}')

  166. 

  167.       if game_over:

  168.           if start:

  169.               print_text(screen, font2, (SCREEN_WIDTH - fwidth) // 2, (SCREEN_HEIGHT - fheight) // 2, 'GAME OVER', RED)

  170. 

  171.       pygame.display.update()

  172. 

  173. 

  174. if __name__ == '__main__':

  175.     main()

  176. 

复制代码
回复

使用道具 举报

精彩评论(5)

RRoy  超级版主

发表于 2023-9-18 16:45:01

666
回复

使用道具 举报

快看擎天猪  高级技师

发表于 2023-9-26 19:10:26

666666666666666666
回复

使用道具 举报

Amos Young  中级技师

发表于 2023-10-4 14:55:41

这个创意有趣，云天老师好帅！
回复

使用道具 举报

_深蓝_  初级技匠

发表于 2023-10-16 17:23:11

这个创意有趣，云天老师好帅！
回复

使用道具 举报

easylot  中级技师 来自手机

发表于 2023-11-14 16:34:33

好教程
回复

使用道具 举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主
勋章墙
活跃会员 宣传大使 创客造 编辑选择奖 志“童”道合 编辑选择奖 编辑选择奖 编辑选择奖

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4 备案 沪公网安备31011502402448

© 2013-2025 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail