精华内容
下载资源
问答
  • 内含有小甲鱼python飞机大战素材源码,代码注释详细,更好地帮助你理解
  • Python版的飞机大战源码素材素材包括有图片和声音
  • 本游戏基于python+pygame开发的一款飞机大战游戏,附上完整代码,图片及素材文件,注释清晰,运行编译过程注意导入包模块。
  • 话不多说,链接奉上: [百度网盘链接: ...提取码:链接: 43av 注:需下载Python pygame包 下载方式:命令行窗口(cmd)输入pip install pygame ...3.运行代码,就可以开始”飞机大战“了。 作者:焚天&无夜
  • 搜集了开发小程序能用到的所有的飞机大战图片,包含Python开发源码,希望 对大家学习python能有所帮助
  • python飞机大战素材图片.齐全,可供参考,需要源码可以联系我,.第一次发帖子,谢谢支持.
  • pygame飞机大战源码素材Python版)完整版

    千次下载 热门讨论 2017-02-22 12:56:39
    Python:pygame飞机大战源码素材
  • Python:pygame飞机大战源码素材
  • 二、pycharm源码文件以及图片素材资源已在主页上传,代码以及运行结果如下: import time import random from PIL import Image import pygame from pygame.constants import * #己方飞机类 class Player...

    一、实现功能包括:多架敌机随机出现,生命数3,死亡时倒计时后重新开局,炸弹随机降落,统计击败敌机数,三张地图每局随机出现,击败敌机数达到10时出现大飞机,大飞机发射子弹更密集等。

    二、pycharm源码文件以及图片素材资源已在主页上传,代码以及运行结果如下:

    import time
    import random
    from PIL import Image
    
    import pygame
    from pygame.constants import *
    
    
    #己方飞机类
    class Player(pygame.sprite.Sprite):
        # 存放所有飞机的子弹的组
        bullets = pygame.sprite.Group()
        def __init__(self,screen):
            # 这个精灵的初始化方法 必须调用
            pygame.sprite.Sprite.__init__(self)
    
            # 创建一个玩家飞机图片,当做真正的飞机
            self.image = pygame.image.load("./feiji/hero1.png")
    
            #通过图片获得矩阵
            self.rect = self.image.get_rect()  # rect:矩形
    
            # 定义飞机初始化坐标
            self.rect.topleft = [Manager.bg_size[0] / 2 - 100 / 2,600]
    
            # 飞机速度
            self.speed = 10
    
            #记录当前窗口对象
            self.screen = screen
    
            #子弹图片
            self.bullet_image = "./feiji/bullet.png"
    
            # 飞机子弹频率 1~100,表示每0.01秒百分之几的概率发射
            self.bullet_frequency = 10
    
    
        def key_control(self):
            # 监听键盘事件
            key_pressed = pygame.key.get_pressed()
    
            if key_pressed[K_w] or key_pressed[K_UP]:
                self.rect.top -= self.speed
            if key_pressed[K_s] or key_pressed[K_DOWN]:
                self.rect.bottom += self.speed
            if key_pressed[K_a] or key_pressed[K_LEFT]:
                # 定义飞机左行驶尽头边界
                if self.rect.left >= 10 :
                    self.rect.left -= self.speed
            if key_pressed[K_d] or key_pressed[K_RIGHT]:
                #定义飞机右行驶尽头边界
                if self.rect.right <= Manager.bg_size[0]:
                    self.rect.right += self.speed
    
            if key_pressed[K_SPACE]:
                # 随机发射子弹
                if  random.randint(0,99) in range(self.bullet_frequency):
                    bullet = Bullet(self.screen ,self.rect.left + 50 - Image.open(self.bullet_image).size[0]/2
                                    ,self.rect.top - Image.open(self.bullet_image).size[1])
                    # 将己方子弹子弹改为
                    bullet.image = pygame.image.load(self.bullet_image)
                    Player.bullets.add(bullet)
    
        #键盘监听控制飞机,飞机的显示
        def update(self):
            self.key_control()
            self.display()
    
    
    
        def display(self):
            # 粘贴飞机坐标
            self.screen.blit(self.image, self.rect)
            #更新子弹坐标
            for i in Player.bullets:
                i.player_fire()
    
            # 对应子弹的update方法
            Player.bullets.update()
            # 把所有子弹全部添加到屏幕
            Player.bullets.draw(self.screen)
    
    
    
    
    #敌方飞机类
    class Enemyplayer(pygame.sprite.Sprite):
        # 放子弹的列表,类属性,通过类名调用
        bullets = pygame.sprite.Group()
        def __init__(self,screen,image ):
            # 这个精灵的初始化方法 必须调用
            pygame.sprite.Sprite.__init__(self)
    
            #记录窗口
            self.screen = screen
    
            #获取敌方飞机图片
            self.image = pygame.image.load(image)
            #通过图片获得矩阵
            self.rect = self.image.get_rect()
            #敌方飞机坐标初始化
            self.rect.topleft = [Manager.bg_size[0]/2 - 50/2,0]
    
            # 放子弹的列表,类属性,通过类名调用
            self.bullets = pygame.sprite.Group()
    
            # 子弹图片
            self.bullet_image = "./feiji/bullet1.png"
    
            #敌方飞机子弹频率 1~100,平均一秒发射几个
            self.bullet_frequency = 3
    
            #敌机移动方向
            self.direciton= "left"
            #飞机是否向下移动
            self.direciton_up = False
    
            #敌机速度
            self.speed = 4
    
        def display(self):
            #粘贴敌机到窗口
            self.screen.blit(self.image,self.rect.topleft)
    
    
        #敌方飞机自动开火方法
        def auto_fire(self):
            #控制敌方子弹频率
            if random.randint(1, 100) in range(0,self.bullet_frequency):
                #通过飞机坐标跟子弹分辨率大小调用子弹对象
                bullet = Bullet(self.screen,self.rect.left + 25 - Image.open(self.bullet_image).size[0]/2
                                ,self.rect.top + Image.open(self.bullet_image).size[1] + 20)
                #将敌方子弹子弹改为
                bullet.image = pygame.image.load(self.bullet_image)
                #向Bullet子弹对象列表增加一个子弹对象
                Enemyplayer.bullets.add(bullet)
    
    
        #敌方飞机自动飞行方法
        def auto_move(self):
    
            if self.direciton == "left":
                self.rect.left -= self.speed
                if self.direciton_up :
                    self.rect.bottom += self.speed
            elif self.direciton == "right":
                self.rect.right += self.speed
                if self.direciton_up:
                    self.rect.bottom += self.speed
            if self.rect.left <= 0 :
                self.direciton = "right"
            elif self.rect.right >=Manager.bg_size[0]:
                self.direciton = "left"
    
        #使敌方飞机飞出窗口时消除该敌方飞机对象
        def kill_enemy(self):
            if self.rect.top > Manager.bg_size[1]:
                self.kill()
    
        #敌方飞机自动移动,自动发射以及显示
        def update(self):
            self.auto_move()
            self.auto_fire()
            self.display()
            self.kill_enemy()
    
    
    #子弹类
    class Bullet(pygame.sprite.Sprite):
        def __init__(self,screen,x,y):
            # 这个精灵的初始化方法 必须调用
            pygame.sprite.Sprite.__init__(self)
            self.screen = screen
            self.image = pygame.image.load("./feiji/bullet.png")
            #通过图片获得矩阵
            self.rect = self.image.get_rect()
            # 初始化子弹坐标
            self.rect.topleft = [x , y ]
            #子弹速度
            self.speed = 8
    
        #己方飞机开火
        def player_fire(self):
            self.rect.top -= self.speed+4
        #敌方飞机开火
        def enemy_fire(self):
            self.rect.bottom += self.speed/2
    
        def update(self):
            # 如果子弹移出屏幕上方 则销毁子弹对象
            if self.rect.top > Manager.bg_size[1] or self.rect.bottom < 0 :
                self.kill()
    
            self.enemy_fire()
            # 把所有子弹全部添加到屏幕
            Enemyplayer.bullets.draw(self.screen)
    
    
    # 炸弹类
    class Bombshell(pygame.sprite.Sprite):
        def __init__(self,screen):
            # 这个精灵的初始化方法 必须调用
            pygame.sprite.Sprite.__init__(self)
            self.screen = screen
            # 传入炸弹图片
            self.image = pygame.image.load("./feiji/bomb-2.gif")
            # 炸弹矩形获取
            self.rect = self.image.get_rect()
            # 炸弹速度
            self.speed = 2
            self.direciton = "left"
            # 炸弹初始坐标
            self.rect.topleft = [0,0]
    
        def auto_move(self):
            # 往左移动
            if self.direciton == "left":
                self.rect.left -= self.speed
                self.rect.bottom += self.speed
            # 往右移动
            elif self.direciton == "right":
                self.rect.right += self.speed
                self.rect.bottom += self.speed
            #左右移动边界
            if self.rect.left <= 0:
                self.direciton = "right"
            elif self.rect.right >= Manager.bg_size[0]:
                self.direciton = "left"
    
    
        # 使敌方炸弹飞出窗口时消除该敌方飞机对象
        def kill_bomb(self):
            if self.rect.top > Manager.bg_size[1]:
                self.kill()
    
        def display(self):
    
            # 粘贴炸弹到窗口
            self.screen.blit(self.image, self.rect.topleft)
    
        def update(self):
            self.auto_move()
            self.display()
            self.kill_bomb()
    
    
    class Bomb(object):
        # 初始化爆炸
        def __init__(self, screen, type):
    
            self.screen = screen
            if type == 'enemy':
                # 加载爆炸资源
                self.mImages = [
                    pygame.image.load("./feiji/enemy0_down" + str(v) + ".png") for v in range(1, 5)]
            else:
                # 加载爆炸资源
                self.mImages = [pygame.image.load(
                    "./feiji/hero_blowup_n" + str(v) + ".png") for v in range(1, 5)]
    
            self.mImages += self.mImages
    
            # 设置当前爆炸播放索引
            self.mIndex = 0
            # 爆炸位置
            self.mPos = [0, 0]
            # 是否可见
            self.mVisible = False
    
        # 设置位置
        def action(self, rect):
            # 触发爆炸方法draw
            # 爆炸的坐标
            self.mPos[0] = rect.left
            self.mPos[1] = rect.top
            # 打开爆炸的开关
            self.mVisible = True
    
        # 绘制爆炸
        def draw(self):
            if not self.mVisible:
                return
            self.screen.blit(self.mImages[self.mIndex], (self.mPos[0], self.mPos[1]))
    
            self.mIndex += 1
            if self.mIndex >= len(self.mImages):
                # 如果下标已经到最后 代表爆炸结束
                # 下标重置 mVisible重置
                self.mIndex = 0
                self.mVisible = False
    
    # 地图
    class GameBackground(object):
        # 初始化地图,传入参数窗口跟地图编号
        def __init__(self, screen,num):
            self.mImage1 = pygame.image.load("./feiji/img_bg_level_"+str(num)+".jpg")
            self.mImage2 = pygame.image.load("./feiji/img_bg_level_"+str(num)+".jpg")
            # 窗口
            self.screen = screen
            # 辅助移动地图
            self.y1 = 0
            self.y2 = -Manager.bg_size[1]  # -768
    
        # 移动地图
        def move(self):
            self.y1 += 2
            self.y2 += 2
            if self.y1 >= Manager.bg_size[1]:
                self.y1 = 0
            if self.y2 >= 0:
                self.y2 = -Manager.bg_size[1]
    
        # 绘制地图
        def draw(self):
            self.screen.blit(self.mImage1, (0, self.y1))
            self.screen.blit(self.mImage2, (0, self.y2))
    
    
    # 背景音乐类
    class GameSound(pygame.sprite.Sprite):
        def __init__(self):
            #这个精灵的初始化方法必须调用
            pygame.sprite.Sprite.__init__(self)
    
            pygame.mixer.init()  # 音乐模块初始化
            pygame.mixer.music.load('./feiji/bg2.ogg') #载入背景音乐
            pygame.mixer.music.set_volume(0.5)  # 声音大小,0.5表示一半大小的声音
            self.__bomb = pygame.mixer.Sound('./feiji/bomb.wav')
    
    
        # 背景音乐
        def playBackgroundMusic(self):
            pygame.mixer.music.play(-1)  # 开始播放音乐,数字表示播放次数,-1表示循环播放
        # 爆炸音乐
        def playBombSound(self):
            self.__bomb.play()
    
    
    class Manager(object):
        #对应图片的窗口大小
        bg_size = (512,768)
    
        #玩家生命数
        life_num = 3
    
        #生成敌方飞机的定时器
        create_enemy_id = 10
    
        #游戏结束定时器
        create_game_over_id = 11
    
        #游戏结束标志
        gameover = False
        #倒计时数
        over_time = 3
    
        #boss最大数量
        boss_num = 10
        # 是否存在boss
        have_boss = False
    
        #初始化击败敌方飞机数
        defeat_num = 0
        def __init__(self):
            pygame.init()
            # 创建一个窗口
            self.screen = pygame.display.set_mode(Manager.bg_size)
            # 生成音乐对象
            self.gamesound = GameSound()
            # 己方飞机精灵组
            self.players = pygame.sprite.Group()
            # 敌方飞机精灵组
            self.enemyplayers = pygame.sprite.Group()
            # 敌方炸弹精灵组
            self.bombshells = pygame.sprite.Group()
            # 创建一个背景图片
            self.background = pygame.image.load(r"./feiji/background.png")
            #创建一个可移动地图 ,随机取一种地图,
            self.move_background_num = random.randint(1,5)
            self.move_background=GameBackground(self.screen,self.move_background_num)
    
    
        def player(self):
            # 调用一个飞机对象
            player = Player(self.screen)
            # 将该飞机对象增加到己方飞机精灵组中
            self.players.add(player)
    
        def enemyplayer(self):
            # 调用一个敌方飞机对象
            enemyplayer = Enemyplayer(self.screen,"./feiji/enemy0.png")
            # 将该飞机对象增加到己方飞机精灵组中
            self.enemyplayers.add(enemyplayer)
    
        #增加多个敌机对象
        def add_enemy(self):
            enemyplayer = Enemyplayer(self.screen,"./feiji/enemy0.png")
            enemyplayer.direciton_up = True
            x = random.randint(0,Manager.bg_size[0])
            #敌机随机出现
            enemyplayer.rect.topleft = (x,0)
            #如果敌机出现在窗口较左边,则敌机优先向右飞行
            if x <= Manager.bg_size[0] / 2:
                enemyplayer.direciton = "right"
            #向敌机精灵组增加一个敌机精灵
            self.enemyplayers.add(enemyplayer)
    
    
    
        #判断碰撞
        def judge_bomb(self,player_bomb,enemy_bomb):
            delete_sprite = False
            if Manager.life_num == 1:
                delete_sprite = True
            # 参1:碰撞对象1 ;参2:碰撞对象2 ;参3:判断调出碰撞对象1还是2还是一起的爆炸图片 ; 参3:是否删除爆炸对象1
            def judge(x1,x2,who,delete1):
                # 判断碰撞对象1(精灵组)与2(精灵组)的碰撞
                iscollide = pygame.sprite.groupcollide(x1, x2, delete1, True)
                if iscollide and (who == "player" or who == "both"):
                    Manager.life_num -= 1
                    if Manager.life_num == 0:
                        # 游戏结束
                        Manager.gameover = True
                        pygame.time.set_timer(Manager.create_game_over_id,1000)
                if iscollide:
                    #取出爆炸对象1
                    items = list(iscollide.items())[0]
                    x = items[0]
                    if who == "player":
    
                        # 传入爆炸位置,打开爆炸图片输出按钮
                        player_bomb.action(x.rect)
                    elif who == "enemy":
                        #x = items[1][0]
                        # 传入敌方爆炸图片的位置
                        enemy_bomb.action(x.rect)
                        # 敌方爆炸击败数加1
                        Manager.defeat_num += 1
                    # 爆炸的声音
    
                    elif who == "both":
                        # 传入爆炸位置,打开爆炸图片输出按钮
                        player_bomb.action(x.rect)
                        # 取出爆炸对象2
                        y = items[1][0]
                        # 传入爆炸对象2的爆炸图片的位置
                        enemy_bomb.action(y.rect)
                        # 敌方爆炸击败数加1
                        Manager.defeat_num += 1
    
                    # 爆炸删除子弹精灵组
                    # Enemyplayer.bullets.empty()
                    #爆炸音乐
                    self.gamesound.playBombSound()
    
            # 判断玩家飞机(精灵组)与敌方子弹(精灵组)的碰撞
            judge(self.players, Enemyplayer.bullets, "player", delete_sprite)
            # 判断玩家飞机(精灵组)与敌方炸弹(精灵组)的碰撞
            judge(self.players, self.bombshells, "player", delete_sprite)
            # 判断敌方飞机(精灵组)与我方子弹(精灵组)的碰撞
            judge(self.enemyplayers, Player.bullets, "enemy", True)
            # 判断玩家飞机(精灵组)与敌方飞机(精灵组)的碰撞
            judge(self.players, self.enemyplayers, "both", delete_sprite)
    
    
    
    
        #召唤boss
        def add_boss(self):
            enemy_boss_player = Enemyplayer(self.screen,"./feiji/enemy1.png")
            enemy_boss_player.bullet_frequency *= 2
            enemy_boss_player.bullet_image ='./feiji/bullet2.png'
            self.enemyplayers.add(enemy_boss_player)
    
    
        # 绘制文字  rgb 红绿蓝 0 - 255
        # 参1要绘制的文字 参2 x轴坐标 参3y轴坐标 参4文字大小 参5 文字颜色 参6 背景颜色
        def drawText(self, text, x, y, textHeight = 30, fontColor = (255, 255, 255), backgroudColor = None):
    
            # 通过字体文件获得字体对象  参数1 字体文件 参数2 字体大小
            font_obj = pygame.font.Font('./feiji/baddf.ttf', textHeight)
            # 1文字  2是否抗锯齿 3文字颜色 4背景颜色
            text_obj = font_obj.render(text, True, fontColor, backgroudColor)  # 配置要显示的文字
            # 获得要显示的对象的rect
            text_rect = text_obj.get_rect()
            # 设置显示对象的坐标
            text_rect.topleft = (x, y)
            # 绘制字 到指定区域  参1是文字对象 参2 矩形对象
            self.screen.blit(text_obj, text_rect)
    
        def show_over_text(self):
            # 游戏结束 倒计时后重新开始
            self.drawText('gameover %d' % Manager.over_time, 100, Manager.bg_size[1] / 2,
                          textHeight=50, fontColor=[255, 0, 0])
    
        #显示击败敌机数
        def show_defeatnum_text(self):
            # 显示击败敌机数
            self.drawText('击败敌机数: %d' % Manager.defeat_num, Manager.bg_size[0]-150, 0,
                          textHeight=20, fontColor=[255, 0, 0])
            # 显示剩余生命数
            self.drawText('剩余生命数: %d' % Manager.life_num, Manager.bg_size[0] - 150, 20,
                          textHeight=20, fontColor=[255, 0, 0])
    
    
    
        def game_over(self):
            # 结束后倒计时
            Manager.over_time -= 1
            self.show_over_text()
            if Manager.over_time == 0:
                # 倒计时结束后游戏重新开始,相应变量返回初始化
                Manager.over_time = 3
                Manager.gameover = False
                self.game_start()
    
    
        def game_start(self):
            # 重新开始游戏,有些类属性要清空
            # 击败敌机数回 0
            Manager.defeat_num = 0
            # 生命数数回 3
            Manager.life_num = 3
            #boss按钮恢复
            Manager.have_boss = False
            #清空飞机类属性的子弹精灵组
            Player.bullets.empty()
            # 清空敌方飞机类属性的子弹精灵组
            Enemyplayer.bullets.empty()
            #重新运行游戏
            manager = Manager()
            manager.main()
    
        def main(self):
    
            # 播放背景音乐
            self.gamesound.playBackgroundMusic()
            # 增加一个己方飞机对象
            self.player()
            # 增加一个敌方飞机对象
            self.enemyplayer()
            # 开启生成敌方飞机定时器
            pygame.time.set_timer(Manager.create_enemy_id, 2000)
            # 初始化一个己方飞机爆炸对象
            player_bomb = Bomb(self.screen, 'player')
            # 初始化一个敌机爆炸的对象
            enemy_bomb = Bomb(self.screen, 'enemy')
    
    
            while True:
                # 调用地图移动方法
                self.move_background.move()
                # 向窗口不断添加背景图
                self.move_background.draw()
                # 窗口显示击败敌机数
                self.show_defeatnum_text()
    
                # 击败敌机数50时,召唤boss
                if Manager.defeat_num == 10 and Manager.have_boss == False:
                    self.add_boss()
                    Manager.have_boss = True
    
                # 随机增加炸弹,平均每十秒增加一个炸弹
                if random.randint(0, 1000) == 1:
                    bombshell = Bombshell(self.screen)
                    # 在窗口最上方左右之间随机出现
                    bombshell.rect.topleft = (random.randint(0, Manager.bg_size[0]), -103)
                    self.bombshells.add(bombshell)
    
                # 对应飞机类里的update方法
                self.players.update()
                self.enemyplayers.update()
                # 不断显示敌方子弹,此为类方法
                Enemyplayer.bullets.update()
                # 显示炸弹
                self.bombshells.update()
    
                #调用爆炸对象调出爆炸图片
                player_bomb.draw()
                enemy_bomb.draw()
    
                if self.players.sprites():
                #调用判断碰撞方法
                    self.judge_bomb(player_bomb,enemy_bomb)
    
                #游戏结束播放倒计时文字
                if Manager.gameover:
                    self.show_over_text()
    
                # 不断更新窗口
                pygame.display.update()
    
                # 遍历所有的事件、
                for event in pygame.event.get():
                    # 判断事件类型如果是pygame的退出
                    if event.type == QUIT:
                        # 执行pygame退出
                        pygame.quit()
                        # python程序的退出
                        exit()
                    elif event.type == Manager.create_enemy_id:
                        # 创建一个敌机
                        self.add_enemy()
                    elif event.type == Manager.create_game_over_id:
                        if Manager.gameover:
                            #游戏结束
                            self.game_over()
                time.sleep(0.01)
    
    
    if __name__ == "__main__":
        manager = Manager()
        manager.main()

    三、运行结果:

     

     

     

    展开全文
  • python实现飞机大战游戏所需要的素材包,包含实现飞机大战游戏需要的所有图像资源
  • python飞机大战.zip

    2019-11-23 15:21:47
    这是我大三python所做的课设,素材是全民飞机的,只制作了一关,有敌机,有boss,配说明文档,代码注释非常的多,很合适python新手
  • 这个是用python语言写的飞机大战游戏,功能不多但精细,可以用来练手,也可以用来上交作业,这是我们小组一起做的,学到了很多,分享一下
  • 学习Python版的飞机大战的,里面含有飞机大战的全部素材飞机大战源码
  • Python飞机大战游戏 附素材源码

    万次阅读 多人点赞 2019-06-30 22:35:26
    效果图: 完整素材源码打包:https://pan.baidu.com/s/1YLn1FZ2IXBxIs53x8pqlrw 提取码: m28g 运行方式:将完整文件夹导入Pycharm后运行 雷霆战机3.0.py 即可 主要代码: # coding:UTF-8 import pygame from pygame...

     效果图:

     

    完整素材源码打包:https://pan.baidu.com/s/1YLn1FZ2IXBxIs53x8pqlrw 提取码: m28g

    运行方式:将完整文件夹导入Pycharm后运行 雷霆战机3.0.py 即可

    主要代码:

    # coding:UTF-8
    import pygame
    from pygame import locals
    from sys import exit
    from pygame.sprite import Sprite,Group
    import random , time , math
    
    
    class BGSprite(Sprite):                             #背景精灵
        def __init__(self,imagepath):
            super().__init__()
            self.image = pygame.image.load(imagepath)
            self.rect = self.image.get_rect()
    
    class EnemySprite(Sprite):                          #敌方战机
        def __init__(self,imagepath,pos,speed,screen,movetype,bullettype,hp): #self,图片路径,创建位置,速度,背景,移动方式,子弹发射方式,血量
            super().__init__()
            self.image = pygame.image.load(imagepath)
            # self.image = self.image.subsurface(rect)
            self.rect = self.image.get_rect()
            self.rect.x = pos[0]
            self.rect.y = pos[1]
            self.speed = speed
            self.xspeed = random.randint(0,speed+1) * movetype
            self.timer = 0
            self.timer2 = 3
            self.bulletgroup = Group()
            self.screen = screen
            self.bullettype = bullettype
            self.hp = hp
    
        def update(self):
            self.bulletgroup.update()
            self.bulletgroup.draw(self.screen)
            if self.bullettype == 0:
                self.timer += 0.01
                if self.timer > 1:
                    # print("敌机发射子弹")
                    bullet = EnemyBulletSprite("images/bullet/enemy_bullet1.png", [self.rect.x + 40, self.rect.y + 39.5],
                                               -2, 0)
                    bullet2 = EnemyBulletSprite("images/bullet/enemy_bullet1.png", [self.rect.x + 40, self.rect.y + 39.5],
                                                -2, -1)
                    bullet3 = EnemyBulletSprite("images/bullet/enemy_bullet1.png", [self.rect.x + 40, self.rect.y + 39.5],
                                                -2, 1)
                    self.bulletgroup.add(bullet)
                    self.bulletgroup.add(bullet2)
                    self.bulletgroup.add(bullet3)
                    self.timer = 0
            else:
                self.timer += 0.01
                self.timer2 += 0.01
                if self.timer > 1:
                    bullet = EnemyBulletSprite("images/bullet/enemy_bullet2.png", [self.rect.x + 40, self.rect.y + 39.5],-2, -1)
                    bullet2 = EnemyBulletSprite("images/bullet/enemy_bullet2.png", [self.rect.x + 120, self.rect.y + 39.5],-2, 1)
                    self.bulletgroup.add(bullet)
                    self.bulletgroup.add(bullet2)
                    self.timer = 0
                if self.timer2 > 4:     #BOSS发射导弹
                    bullet = EnemyBulletSprite("images/bullet/boss_bullet.png", [self.rect.x + 80, self.rect.y + 39.5],-2, 0)
                    self.bulletgroup.add(bullet)
                    self.timer2 = 0
            self.rect.y += self.speed
            self.rect.x += self.xspeed
            if self.rect.x > 400:
                self.xspeed *= -1
                self.rect.x += self.xspeed
            if self.rect.x < 0:
                self.xspeed *= -1
                self.rect.x += self.xspeed
            if self.rect.y > 800:
                self.kill()
    
        def bomb(self):            #爆炸效果
            bombimages = ["images/boom/boom01.png",
                          "images/boom/boom02.png",
                          "images/boom/boom03.png",
                          "images/boom/boom04.png",
                          "images/boom/boom05.png",
                          "images/boom/boom06.png",
                               ]
            for i in bombimages :
                self.screen.blit(pygame.image.load(i),(self.rect.x,self.rect.y))
                time.sleep(0.005)
                pygame.display.update()
            self.kill()
    
    class BulletHelp(Sprite):                               #补给品
        def __init__(self,imagepath,rect,pos,speed,screen,movetype):    #self,图片路径,创建位置,背景,移动方式
            super().__init__()
            self.image = pygame.image.load(imagepath)
            self.image = self.image.subsurface(rect)
            self.rect = self.image.get_rect()
            self.rect.x = pos[0]
            self.rect.y = pos[1]
            self.speed = speed
            self.xspeed = random.randint(0, speed) * movetype
            self.screen = screen
        def update(self):
            self.rect.y += self.speed
            self.rect.x += self.xspeed
            if self.rect.x > 400:
                self.xspeed *= -1
                self.rect.x += self.xspeed
            if self.rect.x < 0:
                self.xspeed *= -1
                self.rect.x += self.xspeed
            if self.rect.y > 800:
                self.kill()
    
    class BulletSprite(Sprite):                             #玩家子弹精灵租
        def __init__(self,imagepath,pos,speed,direction):    #self,图片路径,位置,速度,方向
            super().__init__()
            self.image = pygame.image.load(imagepath)
            # self.image = self.image.subsurface(rect)
            self.rect = self.image.get_rect()
            self.rect.x = pos[0]
            self.rect.y = pos[1]
            self.speed = speed
            self.dir = direction
        def move(self):
            if self.dir == 0:
                self.rect.y -= self.speed
            elif self.dir > 0 :
                self.rect.y -= self.speed * math.sin(self.dir)
                self.rect.x -= self.speed * math.cos(self.dir+90)
            else:
                self.rect.y -= self.speed * math.sin(self.dir * -1 )
                self.rect.x += self.speed * math.cos(self.dir * -1 + 90)
            if self.rect.y < -50:
                self.kill()
        def update(self):
            self.move()
    
    class EnemyBulletSprite(Sprite):                             #敌机子弹精灵组
        def __init__(self,imagepath,pos,speed,direction):     #self,图片路径,位置,速度,方向
            super().__init__()
            self.image = pygame.image.load(imagepath)
            # self.image = self.image.subsurface(rect)
            self.rect = self.image.get_rect()
            self.rect.x = pos[0]
            self.rect.y = pos[1]
            self.speed = speed
            self.dir = direction
        def move(self):
            self.rect.y -= self.speed
            if self.rect.y < -50:
                self.kill()
        def move2(self):
            self.rect.y -= self.speed
            self.rect.x -= self.speed/2
            if self.rect.y < -50:
                self.kill()
        def move3(self):
            self.rect.y -= self.speed
            self.rect.x += self.speed/2
            if self.rect.y < -50:
                self.kill()
        def update(self):       #子弹发射方向
            if self.dir == 0:
                self.move()
            elif self.dir == -1:
                self.move2()
            elif self.dir == 1:
                self.move3()
    
    class PlayerSprite(Sprite):                                 #玩家战机
        def __init__(self,imagepath,rect,pos,speed,screen):     #self,图片路径,位置,速度,背景
            super().__init__()
            self.image = pygame.image.load(imagepath)
            self.image = self.image.subsurface(rect)
            self.rect = self.image.get_rect()
            self.rect.x = pos[0]
            self.rect.y = pos[1]
            self.speed = speed
            self.screen = screen
            self.bulletgroup = Group()
            self.score = 0
            self.hp = 10000
            self.timer = 0
            # self.canfire = False
            self.bullettype = 0
            self.bulletnum = 10
        def move(self):
            keys = pygame.key.get_pressed()
            if keys[locals.K_RIGHT]:
                self.rect.x += self.speed
                if self.rect.x > 412:
                    self.rect.x = 412
            if keys[locals.K_LEFT]:
                self.rect.x -= self.speed
                if self.rect.x < 0:
                    self.rect.x = 0
            if keys[locals.K_UP]:
                self.rect.y -= self.speed
                if self.rect.y < 0:
                    self.rect.y = 0
            if keys[locals.K_DOWN]:
                self.rect.y += self.speed
                if self.rect.y > 702:
                    self.rect.y = 702
        def fire(self):
            self.timer += 1
            if self.timer > 50:
                self.timer = 0
                if self.bullettype == 0:
                    bullet = BulletSprite("images/bullet/bullet1.png",  [self.rect.x + 45, self.rect.y - 20], 6,0)
                    self.bulletgroup.add(bullet)
                elif self.bullettype == 1:
                    bullet = BulletSprite("images/bullet/bullet1.png", [self.rect.x + 30, self.rect.y - 20], 6,0)
                    bullet2 = BulletSprite("images/bullet/bullet1.png", [self.rect.x + 60, self.rect.y - 20], 6,0)
                    self.bulletgroup.add(bullet)
                    self.bulletgroup.add(bullet2)
                elif self.bullettype == 2:
                    bullet = BulletSprite("images/bullet/bullet1.png", [self.rect.x + 30, self.rect.y - 20], 6,0)
                    bullet2 = BulletSprite("images/bullet/bullet1.png", [self.rect.x + 60, self.rect.y - 20], 6,0)
                    bullet3 = BulletSprite("images/bullet/bullet3r.png", [self.rect.x + 60, self.rect.y - 20], 6,15)
                    bullet4 = BulletSprite("images/bullet/bullet3l.png", [self.rect.x + 28, self.rect.y - 20], 6,-15.076)
                    bullet5 = BulletSprite("images/bullet/bullet4r.png", [self.rect.x + 60, self.rect.y - 20], 6,45.5)
                    bullet6 = BulletSprite("images/bullet/bullet4l.png", [self.rect.x + 25, self.rect.y - 20], 6,-45.5)
                    self.bulletgroup.add(bullet)
                    self.bulletgroup.add(bullet2)
                    self.bulletgroup.add(bullet3)
                    self.bulletgroup.add(bullet4)
                    self.bulletgroup.add(bullet5)
                    self.bulletgroup.add(bullet6)
                    self.bulletnum -= 1
                    if self.bulletnum <= 0:
                        self.bullettype = 1
        def update(self):
            self.bulletgroup.update()
            self.bulletgroup.draw(self.screen)
            self.move()
            self.fire()
    
    CREATE_ENEMY = locals.USEREVENT + 1        #加入用户事件
    CREATE_BOSS = locals.USEREVENT + 2
    CREATE_BULLET_HELP = locals.USEREVENT + 3
    
    def main():
        pygame.init()
        pygame.display.set_caption("雷霆战机")           #标题名称
        screen = pygame.display.set_mode((512,768))     #背景大小
        bggroup = Group()
        bgsprite = BGSprite("images/bg/bg0.jpg")
        bggroup.add(bgsprite)
        playergroup = Group()
        playersprite = PlayerSprite("images/hero/hero_b_03.png",[0,0,122,105],[bgsprite.rect.w/2 - 61 ,600],5,screen)        #玩家战机
        playergroup.add(playersprite)
        enemygroup = Group()         #敌机精灵组
        bullethelpgroup = Group()    #子弹精灵组
        bossgroup = Group()          #boss精灵组
        pygame.time.set_timer(CREATE_ENEMY,random.randint(500,1000))        #事件触发计时器
        pygame.time.set_timer(CREATE_BOSS, random.randint(3000, 5000))
        pygame.time.set_timer(CREATE_BULLET_HELP,random.randint(3000,5000))
        font = pygame.font.Font(None,32)        #字体设置
    
        while True:
            bggroup.update()        #保持更新
            bggroup.draw(screen)
    
            playergroup.update()
            playergroup.draw(screen)
    
            enemygroup.update()
            enemygroup.draw(screen)
    
            bossgroup.update()
            bossgroup.draw(screen)
    
            bullethelpgroup.update()
            bullethelpgroup.draw(screen)
    
            screen.blit(font.render("Score:"+str(playersprite.score) , True,(255, 0, 0)),(20,20))    #显示分数
            screen.blit(font.render("HP:" + str(playersprite.hp), True, (255, 0, 0)), (20, 60))        #显示血量
    
            pygame.display.update()
    
            check1 = pygame.sprite.groupcollide(playersprite.bulletgroup,enemygroup,True,False)#碰撞检测 销毁子弹 销毁敌机
            if check1:
                enemy.hp -= 1        #如果检测到碰撞,hp-1
                if enemy.hp <= 0:
                    list(check1.values())[0][0].bomb()    #当hp<=0时,播放爆炸动画,玩家分数+100
                    playersprite.score += 100
            check11 = pygame.sprite.groupcollide(playersprite.bulletgroup, bossgroup, True, False)  # 碰撞检测 销毁子弹 销毁敌机
            if check11:
                boss.hp -= 1
                if boss.hp <= 0:
                    list(check11.values())[0][0].bomb()
                    playersprite.score += 500
            check2 = pygame.sprite.groupcollide(playergroup,enemygroup,False,True)
            if check2:
                list(check2.values())[0][0].bomb()
                playersprite.hp -= 1
            check22 = pygame.sprite.groupcollide(playergroup, bossgroup, False, True)
            if check22:
                list(check22.values())[0][0].bomb()
                playersprite.hp -= 1
            #print(enemygroup)
            for enemy in enemygroup:
                check3 = pygame.sprite.groupcollide(playergroup,enemy.bulletgroup,False,True)
                if check3:
                    playersprite.hp -= 1
                    #playersprite.bullettype = 0
            for boss in bossgroup:
                check33 = pygame.sprite.groupcollide(playergroup,boss.bulletgroup,False,True)
                if check33:
                    playersprite.hp -= 1
                    #playersprite.bullettype = 0
            if playersprite.hp <= 0:
                playersprite.kill()
            check4 = pygame.sprite.groupcollide(playergroup,bullethelpgroup,False,True)
            if check4:
                if playersprite.bullettype <= 1:
                    playersprite.bullettype += 1
                    playersprite.bulletnum = 10
                else:
                    playersprite.bulletnum = 10
            playersprite.fire()
            for event in pygame.event.get():
                # if event.type == locals.KEYUP:
                #     if event.key == locals.K_SPACE:
                #         playersprite.fire()
                if event.type == locals.QUIT:
                    pygame.quit()
                    exit()
                if event.type == CREATE_ENEMY:    #创建普通敌机
                    enemy = EnemySprite("images/enemy/enemy2.png",[random.randint(0,410),-50],2,screen,random.randrange(-1,1,2),0,1)
                    enemygroup.add(enemy)    #加入敌机精灵组
                if event.type == CREATE_BOSS:     #创建BOSS敌机
                    boss = EnemySprite("images/enemy/boss.png",  [random.randint(0, 410), -50], 1,screen, 0,1,15)
                    bossgroup.add(boss)      #加入boss精灵组
                if event.type == CREATE_BULLET_HELP:    #创建补给道具
                    bullethelp = BulletHelp("images/hero/supply.png",[0,0,40,41],[random.randint(0,410),-50],2,screen,random.randrange(-1,1,2))
                    bullethelpgroup.add(bullethelp)    #加入补给精灵组
    
    
    if __name__ == '__main__':
        main()

     

    展开全文
  • 飞机大战源码素材

    2018-06-14 18:02:53
    参考《python编程从入门到实践》,经过修改的飞机大战源代码和素材python版。适合初学者。
  • 1 importpygame2 from plane_sprites import *345 classPlaneGame(object):6 "...飞机大战主游戏"""78 def __init__(self):9 print("游戏初始化")1011 #1.创建游戏的...

    1 importpygame2 from plane_sprites import *

    3

    4

    5 classPlaneGame(object):6 """飞机大战主游戏"""

    7

    8 def __init__(self):9 print("游戏初始化")10

    11 #1.创建游戏的窗口

    12 self.screen =pygame.display.set_mode(SCREEN_RECT.size)13 #2.创建游戏的时钟

    14 self.clock =pygame.time.Clock()15 #3.调用私有方法,精灵和精灵组的创建

    16 self.__create_sprites()17

    18 #4.设置定时器事件——创建敌机 1S

    19 pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)20 pygame.time.set_timer(HERO_FIRE_EVENT, 500)21

    22 #定义精灵和精灵组

    23 def __create_sprites(self):24 #创建背景精灵和精灵组

    25 bg1 =Background()26 bg2 =Background(True)27 #bg2起始位置在bg1的上方

    28 #bg2.rect.y = -bg2.rect.height

    29

    30 self.back_group =pygame.sprite.Group(bg1, bg2)31

    32 #创建敌机的精灵组

    33 self.enemy_group =pygame.sprite.Group()34

    35 #创建英雄的精灵和精灵组

    36 self.hero =Hero()37 self.hero_group =pygame.sprite.Group(self.hero)38

    39 #游戏循环

    40 defstart_game(self):41 print("游戏开始...")42

    43 whileTrue:44 #1.设置刷新帧率

    45 self.clock.tick(FRAME_PER_SEC)46 #2.事件监听

    47 self.__even_handler()48 #3.碰撞检测

    49 self.__check_collide()50 #4.更新/绘制精灵组

    51 self.__update_sprites()52 #5.更新屏幕显示

    53 pygame.display.update()54

    55 pass

    56

    57 #定义事件监听函数

    58 def __even_handler(self):59 for event inpygame.event.get():60

    61 #判断是否退出游戏

    62 if event.type ==pygame.QUIT:63 PlaneGame.__game_over()64 elif event.type ==CREATE_ENEMY_EVENT:65 #print("敌机出场...")

    66 #创建敌机精灵

    67 enemy =Enemy()68

    69 #将敌机精灵添加到敌机精灵组

    70 self.enemy_group.add(enemy)71 elif event.type ==HERO_FIRE_EVENT:72 self.hero.fire()73 #直接判断键盘按键不能持续的获取按键事件

    74 #elif event.type == pygame.KEYDOWN and event.type == pygame.K_RIGHT:

    75 #print("向右移动...")

    76

    77 #使用键盘模块提供的方法获取键盘按键——键盘模块可以持续的获取键盘按键

    78 keys_pressed =pygame.key.get_pressed()79 #判断元祖中对应的按键索引值

    80 if keys_pressed[pygame.K_RIGHT] orkeys_pressed[pygame.K_d]:81 self.hero.rect.x += 2

    82 elif keys_pressed[pygame.K_LEFT] orkeys_pressed[pygame.K_a]:83 self.hero.rect.x -= 2

    84 elif keys_pressed[pygame.K_UP] orkeys_pressed[pygame.K_w]:85 self.hero.rect.y -= 2

    86 elif keys_pressed[pygame.K_DOWN] orkeys_pressed[pygame.K_s]:87 self.hero.rect.y += 2

    88 else:89 self.hero.speed =090

    91 #定义碰撞检测

    92 def __check_collide(self):93

    94 #1.子弹摧毁敌机—— groupcollide可以判断两个精灵组之间是否碰撞

    95 pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)96

    97 #敌机撞毁英雄——spritecollide可以判断精灵和精灵组之间是否碰撞

    98 enemies =pygame.sprite.spritecollide(self.hero, self.enemy_group, True)99

    100 #判断列表是否有内容

    101 if len(enemies) >0:102

    103 #让英雄牺牲

    104 self.hero.kill()105

    106 #结束游戏

    107 PlaneGame.__game_over()108

    109 #定义精灵组调用update()和draw()方法实现屏幕更新

    110 def __update_sprites(self):111

    112 self.back_group.update()113 self.back_group.draw(self.screen)114 self.enemy_group.update()115 self.enemy_group.draw(self.screen)116 self.hero_group.update()117 self.hero_group.draw(self.screen)118 self.hero.bullets.update()119 self.hero.bullets.draw(self.screen)120

    121 #游戏结束

    122 @staticmethod123 def __game_over():124 print("游戏结束...")125

    126 pygame.quit()127 exit()128

    129

    130 if __name__ == '__main__':131

    132 #创建游戏对象

    133 game =PlaneGame()134

    135 #启动游戏

    136 game.start_game()

    展开全文
  • python写的一个飞机大战的项目,功能比较简单,就是课上讲的内容,主要是使用机灵组控制敌机和英雄飞机
  • 前提条件有两个:安装了python及pip并且环境变量配置好 如何检测两个条件是否满足呐? 在cmd命令窗口输入python如下图: 在cmd命令窗口输入pip如下图: 如果不满足先百度找经验安装并配置环境变量。 接下来开始...

    使用Python实现飞机大战

    前提条件有两个:安装了python及pip并且环境变量配置好。

    安装pygame流程:
    如何检测两个条件是否满足呐?

    在cmd命令窗口输入python如下图:

    在这里插入图片描述

    在cmd命令窗口输入pip如下图:

    在这里插入图片描述

    如果不满足先百度找经验安装并配置环境变量。

    接下来开始Pygame的安装了:

    注意:pygame的安装版本一定要和python的一致

    pygame的下载网站https://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame

    如果python是3.6的并且是64位的选择pygame-1.9.4-cp36-cp36m-win_amd64

    cp36表示是3.6版本 ,cp35则表示是3.5的版本

    然后在cmd命令框中cd进入 pygame-1.9.4-cp36-cp36m-win_amd64的安装路径

    输入 pip install pygame-1.9.4-cp36-cp36m-win_amd64.whl即可,或者直接输入pip install pygame 试试哪一种可安装即可。


    好了 python3和pygame安装好即可以进行pycharm中进行开发飞机大战了。

    以下为完整两个模块的代码,为方便大家及时了解每条代码的含义,本人在程序中分别附上了注释。


    plane_main模块中的代码如下:

    import pygame
    from plane_sprites import *
    
    
    class PlaneGame(object):
        '''飞机大战主游戏'''
    
        #初始化属性
        def __init__(self):
    
            #创建游戏的窗口
            self.screen = pygame.display.set_mode((SCREEN_RECT.size))
            #创建游戏时钟
            self.clock = pygame.time.Clock()
            #调用私有方法,使之来完成精灵和精灵组的创建
            self.__create_sprites()
            # 设置定时器事件,创建敌机  1s出现一个
            pygame.time.set_timer(CREATE_ENEMY_EVENT,2000)
            pygame.time.set_timer(HERO_FIRE_EVENT,500)
    
    
        #创建精灵和精灵组
        def __create_sprites(self):
    
            #创建精灵和精灵组
            background1 = Background()
            #使is _alt为真
            background2 = Background(True)
            self.back_group = pygame.sprite.Group(background1,background2)
    
            #创建敌机的精灵组
            self.enemy_group = pygame.sprite.Group()
    
            #创建英雄的精灵和精灵组
            self.hero = Hero()
            self.hero_group = pygame.sprite.Group(self.hero)
    
    
    
            pass
        #开始游戏
        def start_game(self):
    
            while True:
            #设置刷新帧率
                self.clock.tick(PRAME_PER_SEC)
                #事件监听
                self.__event_handler()
                #碰撞检测
                self.__check_collide()
                #更新/绘制精灵组
                self.__update_sprites()
                #更新显示
                pygame.display.update()
    
        def __event_handler(self):
    
            #获得监听事件列表
            for event in pygame.event.get():
    
                #判断是否退出游戏
                if event.type==pygame.QUIT:
                    PlaneGame.__game_over()
    
                elif event.type == CREATE_ENEMY_EVENT:
                    # print("敌机出场")
    
                    #创建敌机精灵
                    enemy = Enemy()
    
                    #将敌机精灵添加到精灵组
                    self.enemy_group.add(enemy)
                elif event.type == HERO_FIRE_EVENT:
                    self.hero.fire()
                #(事件监听方式)
                # elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
    
                #     print("向右移动...")
            #使用键盘提供的方法获取键盘按键 ——返回一个按键元组 (键盘模块方式)
            keys_pressed = pygame.key.get_pressed()
    
            #判断元组中对应的按键索引
            if keys_pressed[pygame.K_RIGHT]:
                # print("向右移动...")
                self.hero.speed = 3
            elif keys_pressed[pygame.K_LEFT]:
                self.hero.speed = -2.5
            else:
                self.hero.speed = 0
        def __check_collide(self):
    
            #子弹摧毁敌机
            pygame.sprite.groupcollide(self.hero.bullets,self.enemy_group,True,True)
    
            #敌机摧毁英雄
            enemies = pygame.sprite.spritecollide(self.hero,self.enemy_group,True)
    
            #判断列表是否有内容
            if len(enemies) > 0:
    
                #让英雄牺牲
                self.hero.kill()
                #结束游戏
                PlaneGame.__game_over()
    
        def __update_sprites(self):
    
            self.back_group.update()
            self.back_group.draw(self.screen)
    
            self.enemy_group.update()
            self.enemy_group.draw(self.screen)
    
            self.hero_group.update()
    
            self.hero_group.draw(self.screen)
    
            self.hero.bullets.update()
            self.hero.bullets.draw(self.screen)
        #定义静态方法
        @staticmethod
        def __game_over():
    
            print("游戏结束")
    
            pygame.quit()
            exit()
    
    if __name__ == '__main__':
    
        #创建游戏对象
        game = PlaneGame()
        #启动游戏
        game.start_game()
    

    plane_sprites模块中的代码如下:

    import random
    import pygame
    
    
    #屏幕大小的常量
    SCREEN_RECT=pygame.Rect(0,0,480,700)
    #刷新的频率
    PRAME_PER_SEC=60
    #创建敌机的定时器常量
    CREATE_ENEMY_EVENT=pygame.USEREVENT
    #英雄发射子弹事件
    HERO_FIRE_EVENT = pygame.USEREVENT + 1
    
    
    #定义一个GmaeSprite类,并且继承于pygame.Sprite类
    class GameSprite(pygame.sprite.Sprite):
        '''飞机大战游戏精灵'''
    
        def __init__(self,image_name,speed=1):
    
    
            #调用父类的初始化方法
            super().__init__()
    
            #定义对象的属性
    
            self.image=  pygame.image.load(image_name)
            self.rect = self.image.get_rect()
            self.speed = speed
        #重写父类的update方法
        def update(self):
    
            #在屏幕的垂直方向上移动
            self.rect.y += self.speed
    
    
    #重写父类update方法
    class Background(GameSprite):
        '''游戏背景精灵'''
    
        def __init__(self,is_alt=False):
    
            #调用父类方法,实现精灵创建(image,rect,speed)
            super().__init__("./images/background.png")
            #判断是否是交替图像,如果是需要设置初始位置
            if is_alt:
                self.rect.y = - self.rect.height
    
        def update(self):
    
            #调用父类的方法实现垂直移动
            super().update()
            #图像是否移除屏幕,如果移除屏幕,将图像设置到屏幕的上方
            if self.rect.y >= SCREEN_RECT.height:
                self.rect.y = -self.rect.height
    
    
    #定义一个敌机类
    class Enemy(GameSprite):
    
        '''敌机精灵'''
    
        def __init__(self):
    
            #调用父类方法 创建敌机精灵 同时指定敌机图片
            super().__init__("./images/enemy1.png")
            #指定敌机的初始随机速度
            self.speed = random.randint(1,3)
            #指定敌机的初始随机位置
            self.rect.bottom = 0
    
            max_x = SCREEN_RECT.width - self.rect.width
    
            self.rect.x = random.randint(0,max_x)
    
    
    
        def update(self):
    
            #调用父类方法,保持垂直方向的奉行
            super().update()
    
            #判断是否飞出屏幕,如果飞出屏幕,需要从精灵组删除敌机
    
            if self.rect.y >= SCREEN_RECT.height:
                #print("敌机飞出屏幕,需要从精灵组删除...")
                #kill方法可以将精灵从所有精灵组中移出,精灵就会被自动销毁
                self.kill()
    
    
    
    class Hero(GameSprite):
        '''英雄精灵'''
    
        def __init__(self):
    
            #调用父类方法,设置image和speed
            super().__init__("./images/me1.png",0)
            #设置英雄的初始位置
            self.rect.centerx = SCREEN_RECT.centerx
            self.rect.bottom = SCREEN_RECT.bottom - 70
    
            #创建子弹的精灵组
    
            self.bullets = pygame.sprite.Group()
        #重写父类方法
        def update(self):
    
            #英雄在水平方式移动
            self.rect.x += self.speed
    
            #控制英雄不能离开屏幕
    
            if self.rect.x < 0:
                self.rect.x = 0
    
            elif self.rect.right > SCREEN_RECT.right:
                self.rect.right = SCREEN_RECT.right
    
    
        def fire(self):
            # print("发射子弹...")
    
    
            for i in (0,1,2):
    
                #创建子弹精灵
                bullet = Bullet()
    
                #设置精灵的位置
                bullet.rect.bottom = self.rect.y - i*25
                bullet.rect.centerx = self.rect.centerx
    
                #将子弹精灵添加到精灵组
                self.bullets.add(bullet)
    
    
    
    class Bullet(GameSprite):
        '''子弹精灵'''
    
        def __init__(self):
    
            #调用父类方法设置子弹图片,设置初始速度
            super().__init__("./images/bullet1.png",-4)
    
    
    
        def update(self):
    
            #调用父类方法,让子弹沿垂直方向飞行
            super().update()
    
            #判断子弹是否飞出屏幕
            if self.rect.bottom < 0:
                self.kill()
    
    
    

    链接:https://pan.baidu.com/s/13jIEQQ9vltr0i3WhHn2CYg
    提取码:impl

    展开全文
  • python坦克大战全系列详细分步骤全开源码素材,非常适合基础python学习者进行基础综合检查
  • 基于Python飞机大战项目小游戏开发的扩展项目,里面包含可执行程序源码素材,本游戏基于python+pygame开发的一款飞机大战游戏,附上完整代码,及游戏包.exe,图片及转换工具,注释清晰,游戏包请以管理员身份运行!
  • 微信经典飞机大战的图片资源,其中还包含python实现源码
  • Python飞机大战代码

    千次阅读 多人点赞 2018-10-30 19:50:22
    Python飞机大战代码,分五个文件存放,每个文件代表着不同的功能! main.py import pygame import sys import traceback import myplane import enemy import bullet import supply from pygame.locals ...
  • 飞机大战python源码+素材飞机大战python源码+素材飞机大战python源码+素材
  • 利用python开发的坦克大战源码加图片文件,直接可以运行。分享给大家自己下载学习和交流.
  • plane_main.py import pygame.time ... """飞机大战主游戏""" def __init__(self): print("游戏初始化") # 1.创建游戏的窗口 self.screen = pygame.display.set_mode(SCREEN_RECT.size) # 2
  • 基于python3.6+pygame开发的飞机大战游戏,有兴趣的可以了解一下,还有可以改进的地方。
  • 飞机大战小游戏的源码和图片素材python入门项目,适合新手练手

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 350
精华内容 140
关键字:

python飞机大战源码素材

python 订阅