外星人入侵

 这次小编上传一个游戏开发的项目，一方面是自己写上去能更好的熟悉这个项目，并且把自己的心得可以分享上面，另一方面，可以让更多的盆友看到，提高自我。

       这个游戏项目使用的是pygame，这是一组强大而有趣的模块，可用于管理图形，动画乃至声音，让你能更轻松的开发复杂的游戏，通过使用pygame来处理在屏幕上绘制图像等任务，我们不用考虑多繁琐而艰难的编程工作，而是将重点放在程序上的高级逻辑上面。

第一步：规划项目

   开发大型项目时候，做好规划再动手编写项目很重要，规划可以确保我们不偏离轨道，从而提高项目成功的可能性。

    下面 来编写有关游戏《外星人入侵》的描述，可能其中没有涵盖所有的游戏细节，但是嗯那个让我们狠清晰的知道如何动手开发它

        在游戏《外星人入侵》中，玩家控制着一艘最初出现在屏幕底部中央的飞船。玩家可以使用箭头键左右移动飞船，还可以使用空格键进行设计。游戏开始时，一群外星人出现在天空，他们在屏幕中向下移动。玩家的任务是射杀这些外星人。玩家将所有的外星人射击干净后，将出现一个新的外星人，他们的移动宿舍更快。只要有外星人撞到玩家的飞船或者到达屏幕底部，玩家就损失一所飞船。玩家损失三艘飞船后，游戏结束。

第二步：安装pygame

       pygame项目托管在代码分享网址Bitbucket中，要在windows系统中安装pygame,则可以访问网站

https://bitbucket.org/pygame/pygame/downloads/

（在网址中查找合适的程序下载）

 

安装程序如下：

pip install pygame-1.9.3-cp36-cp36m-win_amd64.whl

 第三步：开始游戏项目

      首先得创建游戏界面，然后添加飞船图像，飞船添加上去，我们必须允许它可以左右移动，再添加射击子弹的功能。

       然后创建外星人，让外星人移动，我们进行射击外星人，然后结束游戏。

       最后我们得进行记分，提高等级等设置，急需完善游戏，这样一个游戏就设置完毕。

   说起来简单，但是做起来难。这三部分，每部分都是一个整体，而且实现新功能时候，必须重构源代码，一不小心就出错，所以得格外注意。

具体的项目实施步骤，我就在这里不一一讲解了，主要把代码贴出来，让大家参考一下

这个是所有代码的目录：

 

首先是主程序 alien_invasion.py

import pygame
from pygame.sprite import Group

from settings import Settings
from game_stats import GameStats
from scoreboard import Scoreboard
from button import Button
from ship import Ship
from alien import Alien
import game_functions as gf


def run_game():
    # Initialize pygame, settings, and screen object.
    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Alien Invasion")

    #创建play按钮
    play_button = Button(ai_settings,screen,"Play")

    #创建一个用于存储游戏统计信息的实例
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings,screen,stats)

    # Set the background color.
    bg_color = (230, 230, 230)

    # Make a ship.
    ship = Ship(ai_settings, screen)
    # Make a group to store bullets in.
    bullets = Group()
    aliens = Group()

    #创建外星人群
    gf.create_fleet(ai_settings,screen,ship,aliens)

    # Start the main loop for the game.
    while True:
        gf.check_events(ai_settings, screen, stats,sb,play_button,ship,
                        aliens, bullets)

        if stats.game_active:
            ship.update()
            gf.update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets)
            gf.update_aliens(ai_settings,screen,stats,sb,ship,aliens,bullets)

        gf.update_screen(ai_settings, screen,stats, sb,ship,aliens,
                         bullets,play_button)


run_game()

然后是功能函数 game_function.py

import sys
from time import sleep
import pygame

from bullet import Bullet
from alien import Alien
import pygame

def check_keydown_events(event, ai_settings, screen, ship, bullets):
    """Respond to keypresses."""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = True
    elif event.key == pygame.K_LEFT:
        ship.moving_left = True
    elif event.key == pygame.K_SPACE:
        fire_bullet(ai_settings, screen, ship, bullets)


def check_keyup_events(event, ship):
    """Respond to key releases."""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = False
    elif event.key == pygame.K_LEFT:
        ship.moving_left = False


def check_events(ai_settings, screen, stats,sb, play_button,ship,aliens, bullets):
    """Respond to keypresses and mouse events."""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event, ai_settings, screen, ship, bullets)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event, ship)
        elif event.type == pygame.MOUSEBUTTONDOWN:
            mouse_x,mouse_y = pygame.mouse.get_pos()
            check_play_button(ai_settings, screen,stats,sb,play_button,
                              ship,aliens,bullets,mouse_x,mouse_y)


def check_play_button(ai_settings,screen,stats,sb,play_button, ship,aliens,bullets,mouse_x,mouse_y):
    """玩家单击play按钮开始新游戏"""
    button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
    if button_clicked and not stats.game_active:
        #重置游戏设置
        ai_settings.initialize_dynamic_settings()

        #隐藏光标
        pygame.mouse.set_visible(False)
    if play_button.rect.collidepoint(mouse_x,mouse_y):
        #重置游戏统计信息
        stats.reset_stats()
        stats.game_active = True

        #重置记分牌图像
        sb.prep_score()
        sb.prep_high_score()
        sb.prep_level()
        sb.prep_ships()

        #清空外星人列表和子弹列表
        aliens.empty()
        bullets.empty()

        #创建一群新的外星人，并让其居中
        create_fleet(ai_settings,screen,ship,aliens)
        ship.center_ship()


def fire_bullet(ai_settings, screen, ship, bullets):
    """Fire a bullet, if limit not reached yet."""
    # Create a new bullet, add to bullets group.
    if len(bullets) < ai_settings.bullets_allowed:
        new_bullet = Bullet(ai_settings, screen, ship)
        bullets.add(new_bullet)


def update_screen(ai_settings, screen, stats,sb,ship,
                  aliens,bullets,play_button):
    """Update images on the screen, and flip to the new screen."""
    # Redraw the screen, each pass through the loop.
    screen.fill(ai_settings.bg_color)

    # Redraw all bullets, behind ship and aliens.
    for bullet in bullets.sprites():
        bullet.draw_bullet()
    ship.blitme()
    aliens.draw(screen)

    #显示得分
    sb.show_score()

    #如果游戏处于非活跃状态，就绘制play按钮
    if not stats.game_active:
        play_button.draw_button()


    # Make the most recently drawn screen visible.
    pygame.display.flip()


def update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets):
    """Update position of bullets, and get rid of old bullets."""
    # Update bullet positions.
    bullets.update()

    # Get rid of bullets that have disappeared.
    for bullet in bullets.copy():
        if bullet.rect.bottom <= 0:
            bullets.remove(bullet)
    check_bullet_alien_collisions(ai_settings,screen,stats,sb,ship,aliens,bullets)

def check_bullet_alien_collisions(ai_settings,screen,stats,sb,ship,aliens,bullets):
    #检查是否有子弹击中了外星人
    #如果是这样样，就删除相应的额子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets,aliens,True,True)

    if collisions:
        for aliens in collisions.values():
            stats.score += ai_settings.alien_points*len(aliens)
            sb.prep_score()
        check_high_score(stats,sb)


    if len(aliens) == 0:
         # If the entire fleet is destroyed, start a new level.
        bullets.empty()
        ai_settings.increase_speed()

        #提高等级
        stats.level +=1
        sb.prep_level()

        create_fleet(ai_settings,screen,ship,aliens)



def get_number_aliens_x(ai_settings,alien_width):
    """计算每行可容纳多少个外星人"""
    available_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x = int(available_space_x / (2 * alien_width))
    return number_aliens_x

def get_number_rows(ai_settings,ship_height,aliens_height):
    """计算屏幕可以容纳多少个外星人"""
    avaliable_space_y = (ai_settings.screen_height -(3*aliens_height)-ship_height)
    number_rows = int(avaliable_space_y /(2*aliens_height))
    return number_rows


def create_alien(ai_settings,screen,aliens,alien_number,row_number):
    """创建一个外星人并将其放在当前列"""
    alien = Alien(ai_settings, screen)
    alien_width= alien.rect.width
    alien.x = alien_width + 2 * alien_width * alien_number
    alien.rect.x = alien.x
    alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
    aliens.add(alien)

def create_fleet(ai_settings,screen,ship,aliens):
    """创建外星人群"""
    #创建一个外星人，并计算一行可以容纳多少个外星人,外星人间距为外星人的宽度
    alien = Alien(ai_settings,screen)
    number_aliens_x = get_number_aliens_x(ai_settings,alien.rect.width)
    number_rows = get_number_rows(ai_settings,ship.rect.height,alien.rect.height)

    #创建外星人群
    for row_number in range(number_rows):
        for alien_number in range(number_aliens_x):
            #创建一个外星人并将其加入当前行
             create_alien(ai_settings,screen,aliens,alien_number,row_number)

def check_fleet_edges(ai_settings,aliens):
    """有外星人到达边缘时候采取相应的措施"""
    for alien in aliens.sprites():
        if alien.check_edges():
            change_fleet_direction(ai_settings,aliens)
            break

def change_fleet_direction(ai_settings,aliens):
    """将整群外星人下移，并改变他们的方向"""
    for alien in aliens.sprites():
        alien.rect.y += ai_settings.fleet_drop_speed
    ai_settings.fleet_direction *= -1


def update_aliens(ai_settings,screen,stats,sb,ship,aliens,bullets):
    """检查是否有外星人位于屏幕边缘，更新外星人群中所有外星人的位置"""
    check_fleet_edges(ai_settings,aliens)
    aliens.update()

    #监测外星人和飞船之间的碰撞
    if pygame.sprite.spritecollideany(ship,aliens):
        ship_hit(ai_settings,screen,stats,sb,ship,aliens,bullets)

    #检查是狗友外星人到达屏幕底部
    check_aliens_bottom(ai_settings,screen,stats,sb,ship,aliens,bullets)

def ship_hit(ai_settings,screen,stats,sb,ship,aliens,bullents):
    """响应被外星人撞到的飞船"""

    if stats.ships_left >0:
        # 将shios_left减1
        stats.ships_left -=1

        #更新记分牌
        sb.prep_ships()

    else:
        stats.game_active = False
        #清空外星人列表和子弹列表
        pygame.mouse.set_visible(True)

    aliens.empty()
    bullents.empty()

    #创建一群新的外星人
    create_fleet(ai_settings,screen,ship,aliens)
    ship.center_ship()

    #暂停
    sleep(3)

def check_aliens_bottom(ai_settings,screen,stats,ship,sb,aliens,bullets):
    """检查是否有外星人到达了屏幕底部"""
    screen_rect = screen.get_rect()
    for alien in aliens.sprites():
        if alien.rect.bottom >= screen_rect.bottom:
             #像飞船被撞到一样处理
             ship_hit(ai_settings,stats,screen,ship,sb,aliens,bullets)
             break

def check_high_score(stats,sb):
    """检查是否诞生了新的得分最高"""
    if stats.score > stats.high_score:
        stats.high_score = stats.score
        sb.prep_high_score()

下面是设置函数 settings

class Settings():
    """A class to store all settings for Alien Invasion."""

    def __init__(self):
        """Initialize the game's settings."""
        # Screen settings
        self.screen_width = 1100
        self.screen_height = 700
        self.bg_color = (230, 230, 230)

        # 飞船设置
        #self.ship_speed_factor = 1.5
        #self.bullet_speed_factor = 3
        self.ship_limit = 3

        # Bullet settings
        self.bullet_speed_factor = 3
        self.bullet_width = 3
        self.bullet_height = 25
        self.bullet_color = 60, 60, 60
        self.bullets_allowed = 2

        #外星人设置
        #self.alien_speed_factor = 1
        self.fleet_drop_speed = 10
        #fleet_direction为1表示向右移动，-1表示向左移动
        self.fleet_direction = 1

        #以什么样的速度加快游戏节奏
        self.fleet_drop_speed = 10

        #加快游戏节奏的速度
        self.speedup_scale = 1.1
        #外星人点数提高
        self.score_scale = 1.5

        self.initialize_dynamic_settings()

    def increase_speed(self):
        """提高速度设置"""
        self.ship_speed_factor *= self.speedup_scale
        self.bullet_speed_factor *= self.speedup_scale
        self.alien_speed_factor *= self.speedup_scale

        self.alien_points  = int(self.alien_points * self.score_scale)
        #print(self.alien_points)

    def initialize_dynamic_settings(self):
        """初始化岁游戏进行二变化的设置"""
        self.ship_speed_factor = 1.5
        self.bullet_speed_factor = 3
        self.alien_speed_factor = 3

        # fleet_direction为1表示向右移动，-1表示向左移动
        self.fleet_direction = 1

        #积分
        self.alien_points = 50

这个是我方飞机的设置函数ship.py

import pygame
from pygame.sprite import Sprite

class Ship(Sprite):
    def __init__(self, ai_settings, screen):
        """Initialize the ship, and set its starting position."""
        super(Ship,self).__init__()

        self.screen = screen
        self.ai_settings = ai_settings

        # Load the ship image, and get its rect.
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()
        self.screen_rect = screen.get_rect()

        # Start each new ship at the bottom center of the screen.
        self.rect.centerx = self.screen_rect.centerx
        self.rect.bottom = self.screen_rect.bottom

        # Store a decimal value for the ship's center.
        self.center = float(self.rect.centerx)

        # Movement flags.
        self.moving_right = False
        self.moving_left = False

    def update(self):
        """Update the ship's position, based on movement flags."""
        # Update the ship's center value, not the rect.
        if self.moving_right and self.rect.right < self.screen_rect.right:
            self.center += self.ai_settings.ship_speed_factor
        if self.moving_left and self.rect.left > 0:
            self.center -= self.ai_settings.ship_speed_factor

        # Update rect object from self.center.
        self.rect.centerx = self.center

    def blitme(self):
        """Draw the ship at its current location."""
        self.screen.blit(self.image, self.rect)

    def center_ship(self):
         """让飞船在屏幕上剧中"""
         self.center = self.screen_rect.centerx

这个是敌方飞机的设置函数alien.py

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """表示单个外星人"""

    def __init__(self,ai_settings,screen):
        """初始化外星人并设置其起始位置"""
        super(Alien,self).__init__()
        self.screen = screen
        self.ai_settings = ai_settings

        #加载外星人图像，并设置rect属性
        self.image = pygame.image.load('images/alien.bmp')
        self.rect = self.image.get_rect()

        #每个外星人最初都在屏幕右上角附近
        self.rect.x = self.rect.width
        self.rect.y = self.rect.height

        #存储外星人的准确位置
        self.x = float(self.rect.x)

    def check_edges(self):
        """如果外星人位于屏幕边缘，就返回True"""
        screen_rect = self.screen.get_rect()
        if self.rect.right >=screen_rect.right:
            return True
        elif self.rect.left <=0:
            return True

    def update(self):
        """向左或者向右移动外星人"""
        self.x  += (self.ai_settings.fleet_direction * self.ai_settings.alien_speed_factor)
        self.rect.x = self.x

    def blitme(self):
        """在指定位置绘制外星人"""
        self.screen.blit(self.image,self.rect)

这个是子弹设置的函数bullet.py

import pygame
from pygame.sprite import Sprite


class Bullet(Sprite):
    """A class to manage bullets fired from the ship"""

    def __init__(self, ai_settings, screen, ship):
        """Create a bullet object at the ship's current position."""
        super(Bullet, self).__init__()
        self.screen = screen
        # Create a bullet rect at (0, 0) and then set correct position.
        self.rect = pygame.Rect(0, 0, ai_settings.bullet_width,
                                ai_settings.bullet_height)
        self.rect.centerx = ship.rect.centerx
        self.rect.top = ship.rect.top

        # Store the bullet's position as a decimal value.
        self.y = float(self.rect.y)
        self.color = ai_settings.bullet_color
        self.speed_factor = ai_settings.bullet_speed_factor

    def update(self):
        """Move the bullet up the screen."""
        # Update the decimal position of the bullet.
        self.y -= self.speed_factor
        # Update the rect position.
        self.rect.y = self.y

    def draw_bullet(self):
        """Draw the bullet to the screen."""
        pygame.draw.rect(self.screen, self.color, self.rect)

这个是按钮设置的函数button.py

import pygame.font

class  Button():

    def __init__(self,ai_settings,screen,msg):
        """初始化按钮的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()

        #设置按钮的尺寸和其他属性
        self.width,self.height = 200,50
        self.button_color = (0,255,0)
        self.text_color = (255,255,255)
        self.font = pygame.font.SysFont(None,48)

        #创建按钮的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)

这个是记分牌设置的函数scoreboard.py

import pygame.font
from pygame.sprite import Group

from  ship import Ship

class Scoreboard():
    """显示得分信息的类"""
    def __init__(self,ai_settings,screen,stats):
        """初始化显示得分涉及的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        self.ai_settings = ai_settings
        self.stats = stats


        #显示得分信息时候使用的字体设置
        self.text_color = (30,30,30)
        self.font = pygame.font.SysFont(None,48)

        #准备初始得分图像
        self.prep_score()
        self.prep_high_score()
        self.prep_level()
        self.prep_ships()

        #准备包含最高分和当前的分的图像
        self.prep_score()
        self.prep_high_score()


    def prep_score(self):
        """将得分转化为一副渲染的图像"""
        rounded_score = int(round(self.stats.score,-1))
        score_str = "{: ,}".format(rounded_score)
        self.score_image = self.font.render(score_str,True,self.text_color,
                                            self.ai_settings.bg_color)

        #将得分放在屏幕右上角
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right -20
        self.score_rect.top = 20

    def prep_high_score(self):
        """将最高分转换为渲染的图像"""
        high_score = int(round(self.stats.high_score,-1))
        high_score_str = "{: ,}".format(high_score)
        self.high_score_image = self.font.render(high_score_str, True,
                                                 self.text_color,self.ai_settings.bg_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 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.ships.draw(self.screen)

    def prep_level(self):
        """将等级转化为渲染的图像"""
        self.level_image = self.font.render(str(self.stats.level),True,
                                            self.text_color,self.ai_settings.bg_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_ships(self):
        """显示还剩下多少搜飞船"""
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_settings,self.screen)
            ship.rect.x = 10+ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)

这个是跟踪游戏统计信息的类game_stats.py

class GameStats():
    """跟踪游戏的统计信息"""

    def __init__(self,ai_settings):
        """初始化统计信息"""
        self.ai_settings = ai_settings
        self.reset_stats()

        #游戏刚开始处于0活跃状态
        self.game_active = False

        #在任何情况下都不应重置最高得分
        self.high_score = 0

    def reset_stats(self):
        """初始化在游戏与逆行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit
        self.score = 0
        self.level = 1

第四步：游戏结果展示

图一：开始界面图：

图二：游戏中的图

 

 

第五步：游戏总结

  这个游戏做的比较仓促，还存在许多问题，由于小编只是熟悉一下pygame，所以并没做更深层次的改进。放到这里，一方面记录自己的学习进度，另一方面也希望有想在游戏方面开发的朋友继续改进。

   改进建议一：敌方飞机设置的太多，游戏体验不是很好（这个问题，可以对aliens函数进行修改，从而修改敌方飞机的存在个数等）

  改进建议二：每当玩家关闭游戏并重新开启时候，最高分都会被重置（这个问题，可以调用在sys.exit()前，将最高分写入文件，并在游戏记录里面初始化最高分并且读取它）

  改进建议三：可以扩展游戏，比如让外星人也可以射击飞船，或者外星人加盾等

  改进建议四：可以给游戏加上音效，让玩家得到更好的游戏体验

  改进建议五：可以在关卡后面，提高难度不止是敌方飞机速度的加快，也可以是更难打

  改进建议六 ：可以设置双人游戏，在一台操作器上面

  改进建议七：可以设置局域网，让多人联网操作（但是操作只是让设计者熟悉局域网的代码设置）

（。。。。以后有什么更好的想法，可以补上来，要是有时间或者做这个方向的话，可以再扩展这个代码，这个项目是参考《python编程从入门到实践 》的项目）

 

来源：https://www.cnblogs.com/wj-1314/p/7931922.html