Python_飞机大作战

2019-03-17

算是个很经典的小项目，一直没做过，补一下

创建一个窗口

这里用了一些pygame的库函数，之前没接触过

1. pygame.display
1)set_mode(resolution=(0,0), flags=0, depth=0) -> Surface\nInitialize a window or screen for display
初始化窗口函数，resolution代表着是分辨率，我们上述图片选择的是480*852的图片，所以resolution应该填（480,852），第二个参数flags如果你传递的参数为0，或者无标志参数,他默认的为软件驱动窗口，大多数的情况我们选择为0，第三个参数depth表示用于颜色的位数，默认为0，我们可以通过调整参数让背景色暗色一点

2)update(rectangle=None) -> None\nupdate(rectangle_list) -> None\nUpdate portions of the screen for software displays
更新一下surface

3)screen.blit(myImage, pos, srcRect, 0)
第一个参数是源Surface对象，pos则是传送到screen的左上角的位置，是一个二元组，表示xy坐标， srcRect表示的是一个矩形四元组，是将myImage中srcRect这个矩形的区域传送到screen上来

总体而言最基本的就是，创建surface对象，准备一个背景图片，再surface添加图片后更新一下

我们现在创建一个surface，摆上我们的背景图

import pygame
import time


def main():
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('./images/background.png')

    while True:
        # 显示到屏幕
        screen.blit(background, (0, 0))
        pygame.display.update()
        time.sleep(0.05)


if __name__ == '__main__':
    main()

创建玩家的飞机

我们不光要把飞机弄好，还要把上下左右移动的监听写好

飞机的类还是简单的，如下

class HeroPlane(object):
    def __init__(self, screen_temp):
        self.x = 220
        self.y = 650
        self.screen = screen_temp  # 游戏窗口
        self.image = pygame.image.load('images/life.png')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))   # 加载玩家飞机到窗口

    def move_left(self):
        self.x -= 5

    def move_right(self):
        self.x += 5

然后上下左右怎么监听，我去特地搜了一下pygame是怎么做的

1. pygame.event
先列举一下常用的事件列表
QUIT,ACTIVEEVENT,KEYUP,KEYDOWN,MOUSEMOTION,MOUSEBUTTONUP,MOUSEBUTTONDOWN,JOYAXISMOTION,JOYBALLMOTION,JOYHATMOTION
KEYDOWN是个按键的总事件，里面可以选择监听道德是否为某一个键，比如，K_a就是A键
1) pygame.event.get 
获取监听到的事件
2）event.type == QUIT
就是surface的大叉键

接下来我们的飞机就可以左右移动啦

import pygame
import time
from pygame.locals import *


class HeroPlane(object):
    def __init__(self, screen_temp):
        self.x = 220
        self.y = 650
        self.screen = screen_temp  # 游戏窗口
        self.image = pygame.image.load('images/life.png')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))   # 加载玩家飞机到窗口

    def move_left(self):
        self.x -= 5

    def move_right(self):
        self.x += 5


def key_control(hero_temp):
    # 获取事件，比如按键等
    for event in pygame.event.get():
        # 判断是否是点击了退出按钮
        if event.type == QUIT:
            print("exit")
            exit()
        # 判断是否是按下了键
        elif event.type == KEYDOWN:
            # 检测按键是否是a或者left
            if event.key == K_a or event.key == K_LEFT:
                print('left')
                hero_temp.move_left()

            # 检测按键是否是d或者right
            elif event.key == K_d or event.key == K_RIGHT:
                print('right')
                hero_temp.move_right()
            # 检测按键是否是空格键
            elif event.key == K_SPACE:
                print('space')


def main():
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('images/background.png')
    # 创建一个飞机对象
    hero = HeroPlane(screen)

    while True:
        # 显示到屏幕
        screen.blit(background, (0, 0))
        # 显示玩家飞机到定义的（x,y）坐标位置
        hero.display()
        pygame.display.update()
        # 检测键盘，控制玩家飞机移动
        key_control(hero)
        time.sleep(0.02)


if __name__ == '__main__':
    main()

制作发射子弹

之前的空格键就是用来发射子弹的，我们给子弹重新创建一个类是比较好的选择

直接看完整代码就好，目前已经可以发射子弹了，其实就是在之前的基础上加了一点

这里还需要判断子弹越界就消失，不过这个小游戏里面改不改我觉得无伤大雅，但我自己还是写了

import pygame
import time
from pygame.locals import *


class HeroPlane(object):
    def __init__(self, screen_temp):
        self.x = 220
        self.y = 650
        self.screen = screen_temp  # 游戏窗口
        self.image = pygame.image.load('images/life.png')
        self.bullet_list = []  # 存储发射出去的子弹

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))   # 加载玩家飞机到窗口
        for bullet in self.bullet_list:
            bullet.display()
            bullet.move()
            if bullet.judge():  # 判断子弹是否越界
                self.bullet_list.remove(bullet)

    def move_left(self):
        self.x -= 5

    def move_right(self):
        self.x += 5

    def fire(self):
        self.bullet_list.append(Bullet(self.screen, self.x, self.y))


class Bullet(object):
    def __init__(self, screen_temp, x, y):
        self.x = x + 20
        self.y = y - 20
        self.screen = screen_temp
        self.image = pygame.image.load('images/bullet1.png')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        self.y -= 20
    
        def judge(self):
        if self.y < 0:
            return True
        else:
            return False


def key_control(hero_temp):
    # 获取事件，比如按键等
    for event in pygame.event.get():
        # 判断是否是点击了退出按钮
        if event.type == QUIT:
            print("exit")
            exit()
        # 判断是否是按下了键
        elif event.type == KEYDOWN:
            # 检测按键是否是a或者left
            if event.key == K_a or event.key == K_LEFT:
                print('left')
                hero_temp.move_left()

            # 检测按键是否是d或者right
            elif event.key == K_d or event.key == K_RIGHT:
                print('right')
                hero_temp.move_right()
            # 检测按键是否是空格键
            elif event.key == K_SPACE:
                print('space')
                hero_temp.fire()  # 开火


def main():
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('images/background.png')
    # 创建一个飞机对象
    hero = HeroPlane(screen)

    while True:
        # 显示到屏幕
        screen.blit(background, (0, 0))
        # 显示玩家飞机到定义的（x,y）坐标位置
        hero.display()
        pygame.display.update()
        # 检测键盘，控制玩家飞机移动
        key_control(hero)
        time.sleep(0.02)


if __name__ == '__main__':
    main()

创建敌机

没有对手是孤独的，没有条件就创造条件

这里创建一个敌机的类还是轻松的，左右移动也是老样子，只不过直接规定一个出事的默认移动方向就好，然后在初步定义一个判断何时改变运动轨迹的条件即可

# 敌机的class
class EnemyPlane(object):
    def __init__(self, screen_temp):
        self.x = 0
        self.y = 0
        self.screen = screen_temp
        self.image = pygame.image.load('images/enemy1.png')
        self.direction = 'right'  # 定义敌机默认往右移动

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        if self.direction == 'right':
            self.x += 8
        elif self.direction == 'left':
            self.x -= 8

        if self.x > 430:
            self.direction = 'left'
        elif self.x < 0:
            self.direction = 'right'
 
………………
# 如今的main函数
def main():
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('images/background.png')
    # 创建一个飞机对象
    hero = HeroPlane(screen)
    # 创建一个敌机
    enemy = EnemyPlane(screen)

    while True:
        # 显示到屏幕
        screen.blit(background, (0, 0))
        # 显示玩家飞机到定义的（x,y）坐标位置
        hero.display()
        # 显示敌机
        enemy.display()
        enemy.move()
        pygame.display.update()
        # 检测键盘，控制玩家飞机移动
        key_control(hero)
        time.sleep(0.02)

以上部分完成后会出现一个自动移动的敌机，接下来我们给敌机添加子弹

其实还是差不多的，之后为了好看点，我换了点子弹的图片而已，现在一个没有任何歼灭敌机以及爆炸效果的破产游戏就诞生了，完整代码如下

import pygame
import time
import random
from pygame.locals import *


class HeroPlane(object):
    def __init__(self, screen_temp):
        self.x = 220
        self.y = 650
        self.screen = screen_temp  # 游戏窗口
        self.image = pygame.image.load('images/life.png')
        self.bullet_list = []  # 存储发射出去的子弹

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))   # 加载玩家飞机到窗口
        for bullet in self.bullet_list:
            bullet.display()
            bullet.move()
            if bullet.judge():  # 判断子弹是否越界
                self.bullet_list.remove(bullet)

    def move_left(self):
        self.x -= 15

    def move_right(self):
        self.x += 15

    def fire(self):
        self.bullet_list.append(Bullet(self.screen, self.x, self.y))


class Bullet(object):
    def __init__(self, screen_temp, x, y):
        self.x = x + 20
        self.y = y - 20
        self.screen = screen_temp
        self.image = pygame.image.load('images/bullet-3.gif')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        self.y -= 20

    def judge(self):
        if self.y < 0:
            return True
        else:
            return False


class EnemyPlane(object):
    def __init__(self, screen_temp):
        self.x = 0
        self.y = 0
        self.screen = screen_temp
        self.image = pygame.image.load('images/enemy1.png')
        self.bullet_list = []  # 存储发射出去的子弹
        self.direction = 'right'  # 定义敌机默认往右移动

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))
        for bullet in self.bullet_list:
            bullet.display()
            bullet.move()
            if bullet.judge():  # 判断子弹是否越界
                self.bullet_list.remove(bullet)

    def move(self):
        if self.direction == 'right':
            self.x += 8
        elif self.direction == 'left':
            self.x -= 8

        if self.x > 430:
            self.direction = 'left'
        elif self.x < 0:
            self.direction = 'right'

    def fire(self):
        random_num = random.randint(1, 80)
        if random_num == 10 or random_num == 40:
            self.bullet_list.append(EnemyBullet(self.screen, self.x, self.y))


class EnemyBullet(object):
    def __init__(self, screen_temp, x, y):
        self.x = x + 20
        self.y = y + 20
        self.screen = screen_temp
        self.image = pygame.image.load('images/bullet-2.gif')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        self.y += 10

    def judge(self):
        if self.y > 650:
            return True
        else:
            return False


def key_control(hero_temp):
    # 获取事件，比如按键等
    for event in pygame.event.get():
        # 判断是否是点击了退出按钮
        if event.type == QUIT:
            print("exit")
            exit()
        # 判断是否是按下了键
        elif event.type == KEYDOWN:
            # 检测按键是否是a或者left
            if event.key == K_a or event.key == K_LEFT:
                print('left')
                hero_temp.move_left()

            # 检测按键是否是d或者right
            elif event.key == K_d or event.key == K_RIGHT:
                print('right')
                hero_temp.move_right()
            # 检测按键是否是空格键
            elif event.key == K_SPACE:
                print('space')
                hero_temp.fire()  # 开火


def main():
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('images/background.png')
    # 创建一个飞机对象
    hero = HeroPlane(screen)
    # 创建一个敌机
    enemy = EnemyPlane(screen)

    while True:
        # 显示到屏幕
        screen.blit(background, (0, 0))
        # 显示玩家飞机到定义的（x,y）坐标位置
        hero.display()
        # 显示敌机
        enemy.display()
        enemy.move()
        # 敌机开火
        enemy.fire()
        pygame.display.update()
        # 检测键盘，控制玩家飞机移动
        key_control(hero)
        time.sleep(0.02)


if __name__ == '__main__':
    main()

爆炸效果

高大上一点我们可以叫它碰撞检测，pygame.sprite库中，有一些函数可以用于碰撞检测

pygame.sprite.collide_rect()：检测两个精灵是否碰撞，两个精灵视为矩形。

pygame.sprite.collide_circle()：检测两个精灵是否碰撞，两个精灵视为圆形。

pygame.sprite.groupcollide()：检测两个精灵组是否碰撞，依次判断精灵组A中的每一个精灵是否与精灵组B中的每一个精灵发生碰撞

我们有一大堆子弹，groupcollide显然是最优的选择

我们先看一下这个函数的doc

detect collision between a group and another group

pygame.sprite.groupcollide(groupa, groupb, dokilla, dokillb): return dict

Given two groups, this will find the intersections between all sprites in each group. It returns a dictionary of all sprites in the first group that collide.
The value for each item in the dictionary is a list of the sprites in the second group it collides with. 
The two dokill arguments control if the sprites from either group will be automatically removed from all groups.
Collided is a callback function used to calculate if two sprites are colliding.
It should take two sprites as values, and return a bool value indicating if they are colliding. 
If collided is not passed, all sprites must have a "rect" value, which is a rectangle of the sprite area that will be used to calculate the collision.

翻译：
检测组与另一组之间的冲突

pygame.sprite.groupcollide（groupa，groupb，dokilla，dokillb）：return dict

给定两组，这将找到每组中所有精灵之间的交叉点。 它返回第一组中碰撞的所有精灵的字典。
字典中每个项目的值是它碰撞的第二个组中的精灵列表。
两个dokill参数控制是否将从所有组中自动删除任一组中的精灵。
Collided是一个回调函数，用于计算两个精灵是否发生碰撞。
它应该将两个精灵作为值，并返回一个bool值，指示它们是否发生碰撞。
如果未传递碰撞，则所有精灵必须具有“rect”值，该值是用于计算碰撞的精灵区域的矩形。

group1：精灵组1。

group2：精灵组2。

dokill1：发生碰撞时，是否销毁精灵组1中的发生碰撞的精灵。

dokill2：发生碰撞时，是否销毁精灵组2中的发生碰撞的精灵。

collided：自定义的回调函数，你可以自己编写碰撞检测函数。碰撞检测函数的参数是两个精灵，返回值是True/False。

返回一个字典，键是精灵组1中发生碰撞的精灵，值是精灵组2中与该精灵发生碰撞的精灵的列表

现在就是要判断hero的子弹有没有击中敌机，集中的话，产生爆炸效果

这里有一个重要的变化，因为爆炸的原因，为了方便判断大量的子弹以及敌机是否碰撞，我决定只用精灵组，之前的一些class让他们继承精灵的类，基本上是一样

为了效果动态一点（毕竟选择默认的碰撞自动消失是没有特效的），可以用一个list存放效果的图片，然后爆炸的时候像幻灯片一样快速调用就好，就显得很酷炫

这里再介绍一个库函数pygame.Rect

1
2
3

pygame.Rect(left, top, width, height)
分别对应：x,y,图片长度，图片高度
用来裁剪一块矩阵

改完后的代码如下

import pygame
import time
import random
from pygame.locals import *


class HeroPlane(object):
    def __init__(self, screen_temp):
        self.x = 220
        self.y = 650
        self.screen = screen_temp  # 游戏窗口
        self.image = pygame.image.load('images/life.png')
        self.bullet_list = []  # 存储发射出去的子弹
        # 创建子弹精灵组
        self.hero_bullet = pygame.sprite.Group()

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))   # 加载玩家飞机到窗口
        for bullet in self.bullet_list:
            bullet.display()
            bullet.move()
            if bullet.judge():  # 判断子弹是否越界
                self.bullet_list.remove(bullet)

    def move_left(self):
        self.x -= 18

    def move_right(self):
        self.x += 18

    def fire(self):
        h_bullet = Bullet(self.screen, self.x, self.y)
        self.bullet_list.append(h_bullet)
        self.hero_bullet.add(h_bullet)


class Bullet(pygame.sprite.Sprite):
    def __init__(self, screen_temp, x, y):
        pygame.sprite.Sprite.__init__(self)  # 基类的init方法
        self.x = x + 20
        self.y = y - 20
        self.screen = screen_temp
        self.image = pygame.image.load('images/bullet-3.gif')
        # 先用self.rect=self.image.get_rect()获得image距形大小，然后给self.rect设定显示的位置
        self.rect = self.image.get_rect()
        self.rect.topleft = (self.x, self.y)

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        self.y -= 20

    def judge(self):
        if self.y < 0:
            return True
        else:
            return False


class EnemyPlane(pygame.sprite.Sprite):
    def __init__(self, screen_temp):
        pygame.sprite.Sprite.__init__(self)  # 基类的init方法
        self.x = 0
        self.y = 0
        self.explode_index = 0  # 爆炸时钟
        self.screen = screen_temp
        self.image = pygame.image.load('images/enemy1.png')
        self.bullet_list = []  # 存储发射出去的子弹
        self.direction = 'right'  # 定义敌机默认往右移动
        # 先用self.rect=self.image.get_rect()获得image距形大小，然后给self.rect设定显示的位置
        self.rect = self.image.get_rect()
        self.rect.topleft = (self.x, self.y)

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))
        for bullet in self.bullet_list:
            bullet.display()
            bullet.move()
            if bullet.judge():  # 判断子弹是否越界
                self.bullet_list.remove(bullet)

    def move(self):
        if self.direction == 'right':
            self.x += 8
        elif self.direction == 'left':
            self.x -= 8

        if self.x > 430:
            self.direction = 'left'
        elif self.x < 0:
            self.direction = 'right'

    def fire(self):
        random_num = random.randint(1, 80)
        if random_num == 10 or random_num == 40:
            self.bullet_list.append(EnemyBullet(self.screen, self.x, self.y))


class EnemyBullet(object):
    def __init__(self, screen_temp, x, y):
        self.x = x + 20
        self.y = y + 20
        self.screen = screen_temp
        self.image = pygame.image.load('images/bullet-2.gif')

    def display(self):
        self.screen.blit(self.image, (self.x, self.y))

    def move(self):
        self.y += 10

    def judge(self):
        if self.y > 650:
            return True
        else:
            return False


def key_control(hero_temp):
    # 获取事件，比如按键等
    for event in pygame.event.get():
        # 判断是否是点击了退出按钮
        if event.type == QUIT:
            print("exit")
            exit()
        # 判断是否是按下了键
        elif event.type == KEYDOWN:
            # 检测按键是否是a或者left
            if event.key == K_a or event.key == K_LEFT:
                print('left')
                hero_temp.move_left()

            # 检测按键是否是d或者right
            elif event.key == K_d or event.key == K_RIGHT:
                print('right')
                hero_temp.move_right()
            # 检测按键是否是空格键
            elif event.key == K_SPACE:
                print('space')
                hero_temp.fire()  # 开火


# 检测hero的子弹是否击中敌机
def check_e_boom(enemy_group, hero_bullet):
    result = pygame.sprite.groupcollide(enemy_group, hero_bullet, True, True)
    if not result:
        print("OK")
    return result


def main():
    # 创建飞机的爆炸效果
    enemy_hit_surface = list()
    boom_img = pygame.image.load('images/enemy1_down1.png')
    enemy_hit_surface.append(boom_img.subsurface(pygame.Rect(0, 0, 57, 51)))
    boom_img = pygame.image.load('images/enemy1_down2.png')
    enemy_hit_surface.append(boom_img.subsurface(pygame.Rect(0, 0, 57, 51)))
    boom_img = pygame.image.load('images/enemy1_down3.png')
    enemy_hit_surface.append(boom_img.subsurface(pygame.Rect(0, 0, 57, 51)))
    boom_img = pygame.image.load('images/enemy1_down4.png')
    enemy_hit_surface.append(boom_img.subsurface(pygame.Rect(0, 0, 57, 51)))
    # 创建窗口
    screen = pygame.display.set_mode((480, 700))
    # 创建一个背景图片
    background = pygame.image.load('images/background.png')
    # 创建敌机组
    enemy_group = pygame.sprite.Group()
    # 创建一个飞机对象
    hero = HeroPlane(screen)
    # 创建一个敌机
    enemy = EnemyPlane(screen)
    enemy_group.add(enemy)
    # 创建被击中的敌方飞机组
    enemy_hit_group = pygame.sprite.Group()
    # 创建时钟对象 (可以控制游戏循环频率)
    # clock = pygame.time.Clock()

    while True:
        # 每秒循环60次
        # clock.tick(60)
        # 显示到屏幕
        screen.blit(background, (0, 0))
        # 显示玩家飞机到定义的（x,y）坐标位置
        hero.display()
        # 显示敌机
        enemy.display()
        enemy.move()
        # 敌机开火
        enemy.fire()
        result = check_e_boom(enemy_group, hero.hero_bullet)
        if result:
            enemy_hit_group.add(result)
        # 绘制爆炸效果
        for enemy_hit, bullet in enemy_hit_group:
            screen.blit(enemy_hit_surface[enemy_hit.explode_index], (enemy_hit.x, enemy_hit.y))
            if enemy_hit.explode_index < 3:
                enemy_hit.explode_index += 1
            else:
                enemy_hit_group.remove(enemy_hit)
        pygame.display.update()
        # 检测键盘，控制玩家飞机移动
        key_control(hero)
        time.sleep(0.02)


if __name__ == '__main__':
    main()

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2019/03/17/Python-%E9%A3%9E%E6%9C%BA%E5%A4%A7%E4%BD%9C%E6%88%98/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！