python实现飞机大战游戏(pygame版)

目录

 

简介

实现过程

结语


简介

使用python实现pygame版的飞机大战游戏;

  环境:Windows系统+python3.8.0

  游戏规则:

1.点击“PLAY”或者按键“P”开始游戏;

2.敌机根据设置频率从顶部随机位置生成,生成后向下移动;

3.飞船在底部中间生成,玩家使用上下左右键控制飞船移动,敲击空格键发射子弹;

4.子弹打到敌机,该敌机产生爆炸效果并累计分数到右上角;

5.消灭10只飞机后,等级升高,敌机生成频率变快,下落速度也变快;

6.当三条命都消失了,游戏结束。

  游戏运行效果如下:

实现过程

  1. 新建文件“file.py”,用来存储信息到文件和读取文件的信息,本例用来存储和读取最高分;
    import pickle
    # filename = 'file/stats.pkl'
    # 存储信息到文件
    def save_file(obj, filename):
        statsObj = load_file(filename)
        if statsObj == 0:
            # 不存在文件时,直接保存字典
            with open(filename, 'wb') as f:
                pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
        else:
            # 存在文件时,只修改文件中的最高分
            for key, val in statsObj.items():
                # 获取文件最高分的值(当文件字段不止一个时候使用)
                if key == 'highScore':
                    statsObj[key] = obj['highScore']
            obj = statsObj
        with open(filename, 'wb') as f:
            pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
        
    # 读取信息
    def load_file(filename):
        try:
            with open(filename, 'rb') as f:
                return pickle.load(f)
        except FileNotFoundError:
            # 不存在文件则输入错误信息
            msg = "Sorry, the file " + filename + " does not exist."
            print(msg)
            return 0
     
    # obj = {'highScore': 20, 'points': 5}
    # obj = {'highScore': 50}
    # save_file(obj, filename)
    # filedata = load_file(filename)
    # print(filedata)

     

  2. 新建文件settings.py,用来定义一些必须的基本属性和初始值;
    import file as f
    class Settings():
        def __init__(self):
            self.screen_width = 480
            self.screen_height = 660
            self.bg_color = (230, 230, 230)
            # 子弹设置(宽、高、颜色、最大数量)        
            self.bullet_width = 5
            self.bullet_height = 15
            self.bullet_color = 255, 255, 255
            # 敌机移动频率
            self.enemy_frequency = 0
            # 加快游戏节奏的速度
            self.speedup_scale = 1.1
            # 分数的提高速度
            self.score_scale = 1.5
     
            self.initialize_settings()
            # 初始化统计信息
            self.reset_stats()
            # 统计信息文件路径
            self.filename = 'file/stats.pkl'
            # 游戏刚启动时处于非活动状态
            self.game_active = False
            # 读取文件的最高分,在任何情况下都不应重置最高得分
            statsObj = f.load_file(self.filename)
            if statsObj == 0:
                # 不存在文件则显示最高分0
                highScore = 0
            else:
                for key, val in statsObj.items():
                    # 获取文件最高分的值(当文件字段不止一个时候使用)
                    if key == 'highScore':
                        highScore = val
            self.high_score = highScore
             
        def initialize_settings(self):
            """初始化随游戏进行而变化的设置"""
            self.player_move_speed = 2.5
            self.bullet_speed = 3
            self.enemy_move_speed = 1
            # 记分
            self.one_points = 50
        def increase_speed(self):
            """提高速度设置"""
            # self.player_move_speed *= self.speedup_scale
            self.bullet_speed *= self.speedup_scale
            self.enemy_move_speed *= self.speedup_scale
            self.one_points = int(self.one_points * self.score_scale)
        def reset_stats(self):
            """初始化在游戏运行期间可能变化的统计信息"""
            # 可射失的数量
            self.player_limit = 3
            # 射击分数
            self.score = 0
            # 等级
            self.level = 1
            # 打中多少矩形升一级
            self.level_number = 10
            # 生成敌机频率间隔
            self.enemy_frequency_space = 50

     

  3. 新建文件enemy.py,用来定义敌机类(位置topleft随机生成)和声明方法move;
    import pygame
    import random
    from pygame.sprite import Sprite
    class Enemy(Sprite):
        def __init__(self, enemy_down_imgs, settings):
            super(Enemy, self).__init__()
            self.image = pygame.image.load('images/enemy1.png')
            self.rect = self.image.get_rect() 
            self.rect.topleft = [random.randint(0, settings.screen_width - self.rect.width), 0]
            self.down_imgs = enemy_down_imgs
            self.speed = settings.enemy_move_speed
            self.down_index = 0
    
        # 敌机移动,边界判断及删除在游戏主循环里处理
        def move(self):
            self.rect.top += self.speed

     

  4. 新建文件player.py,用来定义玩家类(可上下左右移动)和相应的方法;
    import pygame
    from pygame.sprite import Sprite
    class Player(Sprite):
        def __init__(self, settings, screen):
            super(Player, self).__init__()
            self.settings = settings
            self.screen = screen
            self.screen_rect = self.screen.get_rect()
            # 引入飞船图片并定位
            self.image = pygame.image.load('images/player.png')        
            self.rect = self.image.get_rect()
            self.rect.centerx = self.screen_rect.centerx
            self.rect.bottom = self.screen_rect.bottom
     
            # 移动标志
            self.move_left = False
            self.move_right = False
            self.move_down = False
            self.move_up = False
        def rotate(self, angle):
            # 图片旋转
            self.image = pygame.transform.rotate(self.image, angle)
        def scale(self, multiple):
            # 图片缩放
            self.image = pygame.transform.smoothscale(self.image, (multiple, multiple))
        def update(self):
        	if self.move_left and self.rect.left > self.screen_rect.left:
        		self.rect.centerx -= self.settings.player_move_speed
        	if self.move_right and self.rect.right < self.screen_rect.right:
        		self.rect.centerx += self.settings.player_move_speed
        	if self.move_down and self.rect.bottom < self.screen_rect.bottom:
        		self.rect.centery += self.settings.player_move_speed
        	if self.move_up and self.rect.top > 0:
        		self.rect.centery -= self.settings.player_move_speed
        def draw_player(self):
            """绘制飞船到屏幕"""
            self.screen.blit(self.image, self.rect)

     

  5. 新建文件“bullet.py”,用来定义子弹类(位置在飞船的顶部,并往上移动)和相应的方法;
    import pygame
    from pygame.sprite import Sprite
    class Bullet(Sprite):
        """ 一个对飞船发射的子弹进行管理的类 """
        def __init__(self, settings, screen, player):
            """ 在飞船所处的位置创建一个子弹对象 """
            super(Bullet, self).__init__()
            self.screen = screen
            #  在 (0,0) 处创建一个表示子弹的矩形,再设置正确的位置
            self.rect = pygame.Rect(0, 0, settings.bullet_width, settings.bullet_height)
            self.rect.centerx = player.rect.centerx
                # 飞船顶部
            self.rect.bottom = player.rect.top
            # 存储用小数表示的子弹位置
            self.y = float(self.rect.y)
            self.color = settings.bullet_color
            self.speed = settings.bullet_speed
        def update(self):
            """向上移动子弹"""
            # 更新表示子弹位置的小数值(子弹往右)
            self.y -= self.speed
            # 更新表示子弹的rect的位置
            self.rect.y = self.y
        def draw_bullet(self):
            """在屏幕上绘制子弹"""
            pygame.draw.rect(self.screen, self.color, self.rect)

     

  6. 新建文件“button.py”,用来定义按钮类和相应方法,本例使用于绘制“PLAY”按钮;
    import pygame.font
    class Button():
        def __init__(self, screen, msg):
            """初始化按钮的属性"""
            self.screen = screen
            self.screen_rect = screen.get_rect()
            # 设置按钮的尺寸和其他属性
            self.width, self.height = 100, 30
            self.button_color = (216, 30, 6)
            self.text_color = (255, 255, 255)
            self.font = pygame.font.SysFont(None, 36)
            # 创建按钮的rect对象,并使其居中
            self.rect = pygame.Rect(0, 0, self.width, self.height)
            self.rect.center = self.screen_rect.center
            # 按钮的标签只需创建一次
            self.prep_msg(msg)
        def prep_msg(self, msg):
            """将msg渲染为图像,并使其在按钮上居中"""
            self.msg_image = self.font.render(msg, True, self.text_color, self.button_color)
            self.msg_image_rect = self.msg_image.get_rect()
            self.msg_image_rect.center = self.rect.center
        def draw_button(self):
            # 绘制一个用颜色填充的按钮,再绘制文本
            self.screen.fill(self.button_color, self.rect)
            self.screen.blit(self.msg_image, self.msg_image_rect)

     

  7. 新建文件“scoreboard.py”,用来定义记分板,本例使用于绘制左上角飞船(生命数)、顶部中间的“最高分”、右上角的“积分”和“等级”;
    import pygame.font
    from pygame.sprite import Group
    from player import Player
    class Scoreboard():
        """显示得分信息的类"""
        def __init__(self, settings, screen):
            """初始化显示得分涉及的属性"""
            self.screen = screen
            self.screen_rect = screen.get_rect()
            self.settings = settings
            # 显示得分信息时使用的字体设置
            self.text_color = (255, 255, 255)
            self.font = pygame.font.SysFont(None, 30)
            # 飞船缩放值
            self.scaleValue = 20
            # 准备初始得分图像\最高得分\等级
            self.prep_score()
            self.prep_high_score()
            self.prep_level()
            self.prep_players()
        def prep_score(self):
            """将得分转换为渲染的图像"""
            rounded_score = int(round(self.settings.score, -1))
            score_str = '{:,}'.format(rounded_score)
            self.score_image = self.font.render(score_str, True, self.text_color)
            # 将得分放在屏幕右上角
            self.score_rect = self.score_image.get_rect()
            self.score_rect.right = self.screen_rect.right -20
            self.score_rect.top = 10
        def prep_high_score(self):
            """ 将最高得分转换为渲染的图像 """
            high_score = int(round(self.settings.high_score, -1))
            high_score_str = "{:,}".format(high_score)
            self.high_score_image = self.font.render(high_score_str, True, self.text_color)
            # 将最高得分放在屏幕顶部中央
            self.high_score_rect = self.high_score_image.get_rect()
            self.high_score_rect.centerx = self.screen_rect.centerx
            self.high_score_rect.top = self.score_rect.top
        def prep_level(self):
            """将等级转换为渲染的图像"""
            self.level_image = self.font.render(str(self.settings.level), True, self.text_color)
            # 将等级放在得分下方
            self.level_rect = self.level_image.get_rect()
            self.level_rect.right = self.score_rect.right
            self.level_rect.top = self.score_rect.bottom + 10
        def prep_players(self):
            """ 显示还余下多少艘飞船 """
            self.players = Group()
            for player_number in range(self.settings.player_limit):
                player = Player(self.settings, self.screen)
     
                # 缩放球大小并赋值位置
                player.scale(self.scaleValue)
                player.rect.x = 10 + player.rect.width * player_number * 0.5
                player.rect.y = self.score_rect.top
                self.players.add(player)
        def show_score(self):
            """在屏幕上显示得分"""
            self.screen.blit(self.score_image, self.score_rect)
            self.screen.blit(self.high_score_image, self.high_score_rect)
            self.screen.blit(self.level_image, self.level_rect)
            #  绘制飞船
            self.players.draw(self.screen)

     

  8. 新建文件“game_functions.py”,存放跟游戏有关的所有业务逻辑函数(代码有详细的注释信息);
    import sys
    import pygame
    from bullet import Bullet
    from enemy import Enemy
    import file as f
     
    # 事件
    def check_events(settings, screen, player, play_button, scoreboard, bullets, fireSound):
        """ 响应按键和鼠标事件 """
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                save_file(settings)
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                check_keydown_events(event, settings, screen, player, scoreboard, bullets, fireSound)
            elif event.type == pygame.KEYUP:
                check_keyup_events(event, player)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_x, mouse_y = pygame.mouse.get_pos()
                check_play_button(settings, play_button, scoreboard, mouse_x, mouse_y)
    def check_keydown_events(event, settings, screen, player, scoreboard, bullets, fireSound):
        """ 响应按键 """
        if event.key == pygame.K_DOWN:
            player.move_down = True
        elif event.key == pygame.K_UP:
            player.move_up = True
        elif event.key == pygame.K_LEFT:
            player.move_left = True
        elif event.key == pygame.K_RIGHT:
            player.move_right = True
        elif event.key == pygame.K_SPACE:
            fireSound.play()
            # 点击空格键创建一颗子弹
            fire_bullet(settings, screen, player, bullets)
        elif event.key == pygame.K_p:
            start_game(settings, scoreboard)
        elif event.key == pygame.K_q:
            save_file(settings)
            sys.exit()
    def check_keyup_events(event, player):
        """ 响应松开 """
        if event.key == pygame.K_DOWN:
            player.move_down = False
        elif event.key == pygame.K_UP:
            player.move_up = False
        elif event.key == pygame.K_LEFT:
            player.move_left = False
        elif event.key == pygame.K_RIGHT:
            player.move_right = False
    def check_play_button(settings, play_button, scoreboard, mouse_x, mouse_y):
        """在玩家单击Play按钮时开始新游戏"""
        button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
        if button_clicked and not settings.game_active:
            start_game(settings, scoreboard)
    def start_game(settings, scoreboard):
        """开始游戏"""
        # 重置游戏设置
        settings.initialize_settings()
        # 隐藏光标
        pygame.mouse.set_visible(False)
        # 重置游戏统计信息
        settings.reset_stats()        
        settings.game_active = True
        # 重置记分牌图像
        scoreboard.prep_score()
        scoreboard.prep_high_score()
        scoreboard.prep_level()
        scoreboard.prep_players()
    def save_file(settings):
        # 保持文件
        obj = {'highScore': settings.high_score}
        f.save_file(obj, settings.filename)
     
    # 敌机
    def update_enemies(settings, screen, scoreboard, enemies, enemies_down, enemy_down_imgs, player, bullets, explosiveSound):  
        # 生成敌机,需要控制生成频率
        if settings.enemy_frequency % settings.enemy_frequency_space == 0:        
            enemy1 = Enemy(enemy_down_imgs, settings)
            enemies.add(enemy1)
        settings.enemy_frequency += 1
        if settings.enemy_frequency >= 100:
            settings.enemy_frequency = 0
        for enemy in enemies:
            # 移动敌机
            enemy.move()
            # 敌机与玩家飞机碰撞效果处理 两个精灵之间的圆检测
            if pygame.sprite.collide_circle(enemy, player):
                enemies_down.add(enemy)
                enemies.remove(enemy)
                settings.player_limit -= 1
                scoreboard.prep_players()
                break
            # 移动出屏幕后删除飞机
            if enemy.rect.top < 0:
                enemies.remove(enemy)
        # 敌机被子弹击中效果处理
        # 将被击中的敌机对象添加到击毁敌机 Group 中,用来渲染击毁动画
        # 方法groupcollide()是检测两个精灵组中精灵们的矩形冲突
        enemies1_down = pygame.sprite.groupcollide(enemies, bullets, True, True)
        if enemies1_down:
            explosiveSound.play()
            # 计算分数并渲染
            for enemys in enemies1_down.values():
                settings.score += settings.one_points * len(enemys)
                scoreboard.prep_score()
            # 渲染最高分
            check_high_score(settings, scoreboard)
            # 等达到等级数量升级并渲染新等级
            settings.level_number -= 1
    
            if settings.level_number == 0:
                settings.increase_speed()
                settings.level += 1
                scoreboard.prep_level()
                # 还原为4(同settings一致)
                settings.level_number = 10
                # 加快生成敌机            
                if settings.enemy_frequency_space > 10:
                    settings.enemy_frequency_space -= 10
        # 遍历key值 返回的碰撞敌机
        for enemy_down in enemies1_down:
            # 点击销毁的敌机到列表
            enemies_down.add(enemy_down)
        # 敌机被子弹击中效果显示
        for enemy_down in enemies_down:
            if enemy_down.down_index == 0:
                pass
            if enemy_down.down_index > 7:
                enemies_down.remove(enemy_down)
                continue
            #显示碰撞图片
            screen.blit(enemy_down.down_imgs[enemy_down.down_index // 2], enemy_down.rect)
            enemy_down.down_index += 1
        # 显示精灵
        enemies.draw(screen)    
     
    # 子弹
    def fire_bullet(settings, screen, player, bullets):
        """创建子弹"""
        new_bullet = Bullet(settings, screen, player)
        bullets.add(new_bullet)
    def update_bullets(screen, bullets):
        """更新子弹的位置,并删除已消失的子弹"""
        # 更新子弹的位置
        bullets.update()
     
        # 删除已消失的子弹并同时更新飞船的生命
        for bullet in bullets.copy():
            if bullet.rect.top < screen.get_rect().top:
                bullets.remove(bullet)
     
    # 分数
    def check_high_score(settings, scoreboard):
        """检查是否诞生了新的最高得分"""
        if settings.score > settings.high_score:
            settings.high_score = settings.score
            scoreboard.prep_high_score()
     
    # 屏幕
    def update_screen(settings, screen, player, play_button, scoreboard, enemies, bullets):
        """ 更新屏幕上的图像,并切换到新屏幕 """
        # 绘制飞船到屏幕
        player.draw_player()
        # 绘制子弹到屏幕 
        for bullet in bullets.sprites():
            bullet.draw_bullet()
        # 渲染记分牌信息
        scoreboard.show_score()
        # 
        if settings.player_limit == 0:
            settings.game_active = False
            settings.reset_stats()
            # 清空矩形列表和子弹列表
            enemies.empty()
            bullets.empty()
    
            screen_rect = screen.get_rect()
            player.rect.centerx = screen_rect.centerx
            player.rect.bottom = screen_rect.bottom
        
        # 如果游戏处于非活动状态,就绘制 Play 按钮
        if not settings.game_active:
            play_button.draw_button()
        # 让最近绘制的屏幕可见
        pygame.display.flip()

     

  9. 新建文件shootingenemy.py,主函数用来初始化程序,并同步更新程序的信息;
    import pygame
    from pygame.sprite import Group
    from settings import Settings
    from button import Button
    from player import Player
    import game_functions as gf
    from scoreboard import Scoreboard
     
    def run_game():
        pygame.init()
        # 初始化全部音频,并加载爆炸声音乐
        pygame.mixer.init()
            # 等待1s
        pygame.time.delay(1000)
        pygame.mixer.music.load('file/bgsound.mp3')
            # -1代表无限循环(背景音乐)
        pygame.mixer.music.play(-1)
            # 爆炸声
        explosiveSound = pygame.mixer.Sound('file/explosiveSound.wav')
            # 枪声
        fireSound = pygame.mixer.Sound('file/fireSound.wav')
        # 游戏循环帧率设置
        clock = pygame.time.Clock()
     
        settings = Settings()
        screen = pygame.display.set_mode((settings.screen_width, settings.screen_height))
        # 全屏显示
        # screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
        pygame.display.set_caption('飞机大战')
        # 左上角图标
        ic_launcher = pygame.image.load('images/ic_launcher.png').convert_alpha()
        pygame.display.set_icon(ic_launcher)
        # 背景图
        background = pygame.image.load('images/background.png').convert_alpha()
    
        # 敌机图片
        enemy_img1= pygame.image.load('images/enemy1.png')
        enemy_img2= pygame.image.load('images/enemy2.png')
        enemy_img3= pygame.image.load('images/enemy3.png')
        enemy_img4= pygame.image.load('images/enemy4.png')
        # 敌机不同状态的图片列表,多张图片展示为动画效果
        enemy_down_imgs = []
        enemy_down_imgs.append(enemy_img1)
        enemy_down_imgs.append(enemy_img2)
        enemy_down_imgs.append(enemy_img3)
        enemy_down_imgs.append(enemy_img4)
        # 储存敌机
        enemies = Group()
        # 存储被击毁的飞机,用来渲染击毁动画
        enemies_down = Group()    
    
        # 创建Play按钮
        play_button = Button(screen, 'Play')
     
        # 创建飞船
        player = Player(settings, screen)
        # 创建子弹的编组
        bullets = Group()
        # 创建记分牌
        scoreboard = Scoreboard(settings, screen)
     
        while True:
            # 绘制背景
            screen.blit(background, (0, 0))
            # 控制游戏最大频率
            clock.tick(60)
    
            # 检查玩家输入(不加会导致一直加载)
            gf.check_events(settings, screen, player, play_button, scoreboard, bullets, fireSound)
            if settings.game_active:
                # 更新飞船位置
                player.update()
                # 更新敌机
                gf.update_enemies(settings, screen, scoreboard, enemies, enemies_down, enemy_down_imgs, player, bullets, explosiveSound)
                # 更新子弹位置
                gf.update_bullets(screen, bullets)
            # 更新屏幕信息
            gf.update_screen(settings, screen, player, play_button, scoreboard, enemies, bullets)
     
    run_game()

     

  10. 在文件shootingenemy.py目录路径下,执行命令“python shootingenemy.py”弹出窗口,即可对其操作游玩。

结语

该游戏加入了背景音乐、射击声、子弹射中敌机的爆炸声和爆炸效果、生命数、积分、等级、最高分和开始按钮等元素,大家也可以自行加入其它好玩的元素。

你可能感兴趣的:(python)