• 【pyhon】利用pygame实现彩图版飞机大战（附源码 可供大作业练习使用）

    源码请点赞关注收藏后评论区留言或私信博主

    演示视频已上传到我的主页 有需要者可自行观看 

    演示视频如下：

    飞机大战

     

    接下来先介绍一下游戏的玩法

    在PyCharm中运行《彩图版飞机大战》即可进入如图1所示的游戏界面。

     

    具体的操作步骤如下：

    （1）玩游戏。在游戏主界面中，从屏幕的顶部不断出现下落的敌机，玩家按下键盘上的↑、↓、←、→方向键移动飞机的位置并且发射子弹打掉敌机，每打掉一只敌机得100分。当玩家飞机与敌机发生碰撞时游戏结束，同时显示游戏得分以及排行榜按钮，游戏结束界面如图2所示。

     

    图2  游戏结束界面

    （2）查看排行榜。在游戏结束界面中，单击“排行榜”按钮，将显示排行榜界面，如图3所示。在该界面中，如果想重新玩游戏，可以单击“重新开始”按钮。

     

    图3  游戏排行榜界面

    程序结构如下1：子弹类

    2：玩家飞机类

    3：敌机类

    4：然后对文件的读写操作

    5：对于背景图片的读入和初始化方法

    6：排行榜函数等等

    score.txt文件中内容如下

    14200mr12500mr11600mr10300mr6700mr6500mr4300mr4200mr4100mr4100

    部分源代码如下

    1. # -*- coding: utf-8 -*-
    2. import pygame           # 导入pygame库
    3. from pygame.locals import *  # 导入pygame库中的一些常量
    4. from sys import exit  # 导入sys库中的exit函数
    5. import random
    6. import codecs
    7.  
    8. # 设置游戏屏幕大小
    9. SCREEN_WIDTH = 480
    10. SCREEN_HEIGHT = 800
    11.  
    12. # 子弹类
    13. class Bullet(pygame.sprite.Sprite):
    14.     def __init__(self, bullet_img, init_pos):
    15.         # 调用了父类的初始化方法来初始化sprite的属性
    16.        
    17.         self.rect = self.image.get_rect()
    18.         self.rect.midbottom = init_pos
    19.         self.speed = 10
    20.  
    21.     def move(self):
    22.         self.rect.top -= self.speed
    23.  
    24. # 玩家飞机类
    25. class Player(pygame.sprite.Sprite):
    26.     def __init__(self, player_rect, init_pos):
    27.     用来存储玩家飞机图片的列表
    28.         for i in range(len(player_rect)):
    29.             self.image.append(player_rect[i].convert_alpha())
    30.  
    31.         self.rect = player_rect[0].get_rect()  # 初始化图片所在的矩形
    32.         self.rect.topleft = init_pos  # 初始化矩形的左上角坐标
    33.         self.speed = 8  # 初始化玩家飞机速度，这里是一个确定的值
    34.         self.bullets = pygame.sprite.Group()  # 玩家飞机所发射的子弹的集合
    35.         self.img_index = 0  # 玩家飞机图片索引
    36.         self.is_hit = False  # 玩家是否被击中
    37.  
    38.     # 发射子弹
    39.     def shoot(self, bullet_img):
    40.         bullet = Bullet(bullet_img, self.rect.midtop)
    41.         self.bullets.add(bullet)
    42.  
    43.     # 向上移动，需要判断边界
    44.     def moveUp(self):
    45.         if self.rect.top <= 0:
    46.             self.rect.top = 0
    47.         else:
    48.             self.rect.top -= self.speed
    49.  
    50.     # 向下移动，需要判断边界
    51.     def moveDown(self):
    52.         if self.rect.top >= SCREEN_HEIGHT - self.rect.height:
    53.             self.rect.top = SCREEN_HEIGHT - self.rect.height
    54.         else:
    55.             self.rect.top += self.speed
    56.  
    57.     # 向左移动，需要判断边界
    58.     def moveLeft(self):
    59.         if self.rect.left <= 0:
    60.             self.rect.left = 0
    61.         else:
    62.             self.rect.left -= self.speed
    63.  
    64.     # 向右移动，需要判断边界
    65.     def moveRight(self):
    66.         if self.rect.left >= SCREEN_WIDTH - self.rect.width:
    67.             self.rect.left = SCREEN_WIDTH - self.rect.width
    68.         else:
    69.             self.rect.left += self.speed
    70.  
    71. # 敌机类
    72. class Enemy(pygame.sprite.Sprite):
    73.     def __init__(self, enemy_img, enemy_down_imgs, init_pos):
    74.         pygame.sprite.Sprite.__init__(self)
    75.         self.image = enemy_img
    76.         self.rect = self.image.get_rect()
    77.         self.rect.topleft = init_pos
    78.         self.down_imgs = enemy_down_imgs
    79.         self.speed = 2
    80.         self.down_index = 0
    81.  
    82.     # 敌机移动，边界判断及删除在游戏主循环里处理
    83.     def move(self):
    84.         self.rect.top += self.speed
    85. """ 
    86. 对文件的操作
    87. 写入文本:
    88. 传入参数为content，strim，path；content为需要写入的内容，数据类型为字符串。
    89. path为写入的位置，数据类型为字符串。strim写入方式
    90. 传入的path需如下定义：path= r’ D:\text.txt’
    91. f = codecs.open(path, strim, 'utf8')中，codecs为包，需要用impor引入。
    92. strim=’a’表示追加写入txt，可以换成’w’，表示覆盖写入。
    93. 'utf8'表述写入的编码，可以换成'utf16'等。
    94. """
    95. def write_txt(content, strim, path):
    96.     f = codecs.open(path, strim, 'utf8')
    97.     f.write(str(content))
    98.     f.close()
    99. """
    100. 读取txt：
    101. 表示按行读取txt文件,utf8表 示读取编码为utf8的文件，可以根据需求改成utf16，或者GBK等。
    102. 返回的为数组，每一个数组的元素代表一行，
    103. 若想返回字符串格式，可以将改写成return ‘\n’.join(lines)
    104. """
    105. def read_txt(path):
    106.     with open(path, 'r', encoding='utf8') as f:
    107.         lines = f.readlines()
    108.     return lines
    109.  
    110. # 初始化 pygame
    111. pygame.init()
    112. # 设置游戏界面大小
    113. screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    114. # 游戏界面标题
    115. pygame.display.set_caption('彩图版飞机大战')
    116. # 图标
    117. ic_launcher = pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\ic_launcher.png').convert_alpha()
    118. pygame.display.set_icon(ic_launcher)
    119. # 背景图
    120. background = pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\background.png').convert_alpha()
    121. # 游戏结束背景图
    122. game_over = pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\gameover.png')
    123. # 子弹图片
    124. plane_bullet = pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\bullet.png')
    125. # 飞机图片
    126. player_img1= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\player1.png')
    127. player_img2= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\player2.png')
    128. player_img3= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\player_off1.png')
    129. player_img4= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\player_off2.png')
    130. player_img5= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\player_off3.png')
    131. # 敌机图片
    132. enemy_img1= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\enemy1.png')
    133. enemy_img2= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\enemy2.png')
    134. enemy_img3= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\enemy3.png')
    135. enemy_img4= pygame.image.load(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\resources\image\enemy4.png')
    136. # 开始游戏方法
    137. def startGame():
    138.     # 设置玩家飞机不同状态的图片列表，多张图片展示为动画效果
    139.     player_rect = []
    140.     # 玩家飞机图片
    141.     player_rect.append(player_img1)
    142.     player_rect.append(player_img2)
    143.     # 玩家爆炸图片
    144.     player_rect.append(player_img2)
    145.     player_rect.append(player_img3)
    146.     player_rect.append(player_img4)
    147.     player_rect.append(player_img5)
    148.     player_pos = [200, 600]
    149.     # 初始化玩家飞机
    150.     player = Player(player_rect, player_pos)
    151.     # 子弹图片
    152.     bullet_img = plane_bullet
    153.     # 敌机不同状态的图片列表，多张图片展示为动画效果
    154.     enemy1_img = enemy_img1
    155.     enemy1_rect=enemy1_img.get_rect()
    156.     enemy1_down_imgs = []
    157.     enemy1_down_imgs.append(enemy_img1)
    158.     enemy1_down_imgs.append(enemy_img2)
    159.     enemy1_down_imgs.append(enemy_img3)
    160.     enemy1_down_imgs.append(enemy_img4)
    161.     # 储存敌机
    162.     enemies1 = pygame.sprite.Group()
    163.     # 存储被击毁的飞机，用来渲染击毁动画
    164.     enemies_down = pygame.sprite.Group()
    165.     # 初始化射击及敌机移动频率
    166.     shoot_frequency = 0
    167.     enemy_frequency = 0
    168.     # 玩家飞机被击中后的效果处理
    169.     player_down_index = 16
    170.     # 初始化分数
    171.     score = 0
    172.     # 游戏循环帧率设置
    173.     clock = pygame.time.Clock()
    174.     # 判断游戏循环退出的参数
    175.     running = True
    176.     # 游戏主循环
    177.     while running:
    178.         # 绘制背景
    179.         screen.fill(0)
    180.         screen.blit(background, (0, 0))
    181.         # 控制游戏最大帧率为 60
    182.         clock.tick(60)
    183.         # 生成子弹，需要控制发射频率
    184.         # 首先判断玩家飞机没有被击中
    185.         if not player.is_hit:
    186.             if shoot_frequency % 15 == 0:
    187.                 player.shoot(bullet_img)
    188.             shoot_frequency += 1
    189.             if shoot_frequency >= 15:
    190.                 shoot_frequency = 0
    191.         for bullet in player.bullets:
    192.             # 以固定速度移动子弹
    193.             bullet.move()
    194.             # 移动出屏幕后删除子弹
    195.             if bullet.rect.bottom < 0:
    196.                 player.bullets.remove(bullet)
    197.         # 显示子弹
    198.         player.bullets.draw(screen)
    199.         # 生成敌机，需要控制生成频率
    200.         if enemy_frequency % 50 == 0:
    201.             enemy1_pos = [random.randint(0, SCREEN_WIDTH - enemy1_rect.width), 0]
    202.             enemy1 = Enemy(enemy1_img, enemy1_down_imgs, enemy1_pos)
    203.             enemies1.add(enemy1)
    204.         enemy_frequency += 1
    205.         if enemy_frequency >= 100:
    206.             enemy_frequency = 0
    207.         for enemy in enemies1:
    208.             # 移动敌机
    209.             enemy.move()
    210.             # 敌机与玩家飞机碰撞效果处理 两个精灵之间的圆检测
    211.             if pygame.sprite.collide_circle(enemy, player):
    212.                 enemies_down.add(enemy)
    213.                 enemies1.remove(enemy)
    214.                 player.is_hit = True
    215.                 break
    216.             # 移动出屏幕后删除飞机
    217.             if enemy.rect.top < 0:
    218.                 enemies1.remove(enemy)
    219.         # 敌机被子弹击中效果处理
    220.         # 将被击中的敌机对象添加到击毁敌机 Group 中，用来渲染击毁动画
    221.         # 方法groupcollide()是检测两个精灵组中精灵们的矩形冲突
    222.         enemies1_down = pygame.sprite.groupcollide(enemies1, player.bullets, 1, 1)
    223.         # 遍历key值 返回的碰撞敌机
    224.         for enemy_down in enemies1_down:
    225.             # 点击销毁的敌机到列表
    226.             enemies_down.add(enemy_down)
    227.         # 绘制玩家飞机
    228.         if not player.is_hit:
    229.             screen.blit(player.image[player.img_index], player.rect)
    230.             # 更换图片索引使飞机有动画效果
    231.             player.img_index = shoot_frequency // 8
    232.         else:
    233.             # 玩家飞机被击中后的效果处理
    234.             player.img_index = player_down_index // 8
    235.             screen.blit(player.image[player.img_index], player.rect)
    236.             player_down_index += 1
    237.             if player_down_index > 47:
    238.                 # 击中效果处理完成后游戏结束
    239.                 running = False
    240.         # 敌机被子弹击中效果显示
    241.         for enemy_down in enemies_down:
    242.             if enemy_down.down_index == 0:
    243.                 pass
    244.             if enemy_down.down_index > 7:
    245.                 enemies_down.remove(enemy_down)
    246.                 score += 100
    247.                 continue
    248.             #显示碰撞图片
    249.             screen.blit(enemy_down.down_imgs[enemy_down.down_index // 2], enemy_down.rect)
    250.             enemy_down.down_index += 1
    251.         # 显示精灵
    252.         enemies1.draw(screen)
    253.         # 绘制当前得分
    254.         score_font = pygame.font.Font(None, 36)
    255.         score_text = score_font.render(str(score), True, (255, 255, 255))
    256.         text_rect = score_text.get_rect()
    257.         text_rect.topleft = [10, 10]
    258.         screen.blit(score_text, text_rect)
    259.         # 更新屏幕
    260.         pygame.display.update()
    261.         # 处理游戏退出
    262.         for event in pygame.event.get():
    263.             if event.type == pygame.QUIT:
    264.                 pygame.quit()
    265.                 exit()
    266.         # 获取键盘事件（上下左右按键）
    267.         key_pressed = pygame.key.get_pressed()
    268.         # 处理键盘事件（移动飞机的位置）
    269.         if key_pressed[K_w] or key_pressed[K_UP]:
    270.             player.moveUp()
    271.         if key_pressed[K_s] or key_pressed[K_DOWN]:
    272.             player.moveDown()
    273.         if key_pressed[K_a] or key_pressed[K_LEFT]:
    274.             player.moveLeft()
    275.         if key_pressed[K_d] or key_pressed[K_RIGHT]:
    276.             player.moveRight()
    277.  
    278.     # 绘制游戏结束背景
    279.     screen.blit(game_over, (0, 0))
    280.     # 游戏 Game Over 后显示最终得分
    281.     font = pygame.font.Font(None, 48)
    282.     text = font.render('Score: ' + str(score), True, (255, 255, 255))
    283.     text_rect = text.get_rect()
    284.     text_rect.centerx = screen.get_rect().centerx
    285.     text_rect.centery = screen.get_rect().centery + 24
    286.     screen.blit(text, text_rect)
    287.     # 使用系统字体
    288.     xtfont = pygame.font.SysFont('SimHei', 30)
    289.     # 重新开始按钮
    290.     textstart = xtfont.render('重新开始 ', True, (255, 255, 255))
    291.     text_rect = textstart.get_rect()
    292.     text_rect.centerx = screen.get_rect().centerx
    293.     text_rect.centery = screen.get_rect().centery + 120
    294.     screen.blit(textstart, text_rect)
    295.     # 排行榜按钮
    296.     textstart = xtfont.render('排行榜 ', True, (255, 255, 255))
    297.     text_rect = textstart.get_rect()
    298.     text_rect.centerx = screen.get_rect().centerx
    299.     text_rect.centery = screen.get_rect().centery + 180
    300.     screen.blit(textstart, text_rect)
    301.  
    302.     # 判断得分更新排行榜
    303.     # 临时的变量在到排行榜的时候使用
    304.     j = 0
    305.     #获取文件中内容转换成列表使用mr分割开内容
    306.     arrayscore = read_txt(r'C:\Users\Admin\Desktop\23个 Code\23个 Code\Code\05彩图版飞机大战的程序\源程序\foo\score.txt')[0].split('mr')
    307.     # 循环分数列表在列表里排序
    308.     for i in range(0, len(arrayscore)):
    309.         # 判断当前获得的分数是否大于排行榜上的分数
    310.         if score > int(arrayscore[i]):
    311.             # 大于排行榜上的内容 把分数和当前分数进行替换
    312.             j = arrayscore[i]
    313.             arrayscore[i] = str(score)
    314.             score = 0
    315.         # 替换下来的分数下移动一位
    316.         if int(j) > int(arrayscore[i]):
    317.             k = arrayscore[i]
    318.             arrayscore[i] = str(j)
    319.             j = k
    320.     #  循环分数列表 写入文档
    321.     for i in range(0, len(arrayscore)):
    322.         # 判断列表中第一个分数
    323.         if i == 0:
    324.             # 覆盖写入内容追加mr方便分割内容
    325.             write_txt(arrayscore[i] + 'mr', 'w', r'score.txt')
    326.         else:
    327.             # 判断是否为最后一个分数
    328.             if (i == 9):
    329.                 # 最近添加内容最后一个分数不添加mr
    330.                 write_txt(arrayscore[i], 'a', r'score.txt')
    331.             else:
    332.                 # 不是最后一个分数，添加的时候添加mr
    333.                 write_txt(arrayscore[i] + 'mr', 'a', r'score.txt')
    334.  
    335. # 排行榜
    336. def gameRanking():
    337.     screen2 = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    338.     # 绘制背景
    339.     screen2.fill(0)
    340.     screen2.blit(background, (0, 0))
    341.     # 使用系统字体
    342.     xtfont = pygame.font.SysFont('SimHei', 30)
    343.     # 重新开始按钮
    344.     textstart = xtfont.render('排行榜 ', True, (255, 0, 0))
    345.     text_rect = textstart.get_rect()
    346.     text_rect.centerx = screen.get_rect().centerx
    347.     text_rect.centery = 50
    348.     screen.blit(textstart, text_rect)
    349.     # 重新开始按钮
    350.     textstart = xtfont.render('重新开始 ', True, (255, 0, 0))
    351.     text_rect = textstart.get_rect()
    352.     text_rect.centerx = screen.get_rect().centerx
    353.     text_rect.centery = screen.get_rect().centery + 120
    354.     screen2.blit(textstart, text_rect)
    355.     # 获取排行文档内容
    356.     arrayscore = read_txt(r'score.txt')[0].split('mr')
    357.     # 循环排行榜文件显示排行
    358.     for i in range(0, len(arrayscore)):
    359.         # 游戏 Game Over 后显示最终得分
    360.         font = pygame.font.Font(None, 48)
    361.         # 排名重1到10
    362.         k=i+1
    363.       =
    364.             exit()
    365.         # 鼠标单击
    366.         elif event.type == pygame.MOUSEBUTTONDOWN:
    367.             # 判断鼠标单击的位置是否为开始按钮位置范围内
    368.             if screen.get_rect().centerx - 70 <= event.pos[0] \
    369.                     and event.pos[0] <= screen.get_rect().centerx + 50 \
    370.                     and screen.get_rect().centery + 100 <= event.pos[1] \
    371.                     and screen.get_rect().centery + 140 >= event.pos[1]:
    372.                 # 重新开始游戏
    373.                 startGame()
    374.             # 判断鼠标是否单击排行榜按钮
    375.             if screen.get_rect().centerx - 70 <= event.pos[0] \
    376.                     and event.pos[0] <= screen.get_rect().centerx + 50 \
    377.                     and screen.get_rect().centery + 160 <= event.pos[1] \
    378.                     and screen.get_rect().centery + 200 >= event.pos[1]:
    379.                 # 显示排行榜
    380.                 gameRanking()
    381.     # 更新界面
    382.     pygame.display.update()

     

  • 相关阅读:
    【C++】运算符重载 ⑨ ( 等号 = 运算符重载 | 调用默认浅拷贝构造函数的情况分析 | 等号 = 运算符重载 与 拷贝构造函数 各自使用场景 | 等号 = 操作符重载步骤 )
    JVM
    总结flutter玩转之-安卓view 承载flutter 的页面
    aardio 调用 vs 编写的dll (stdcall方式) (dll又调用另一个dll)
    React + Springboot + Quartz，从0实现Excel报表自动化
    hive的安装配置笔记
    黑马点评-异步秒杀实现
    Grafana+Prometheus打造运维监控系统（一）-安装篇
    Mybatis的关系关联配置
    MySQL间隙锁深入分析
  • 原文地址：https://blog.csdn.net/jiebaoshayebuhui/article/details/127623998