【Python编程：从入门到实践】第十三章练习题

13-1 星星 ：找一幅星星图像，并在屏幕上显示一系列整齐排列的星星。
13-2 更逼真的星星 ：为让星星的分布更逼真，可随机地放置星星。

合并为一个程序“满天星”，效果图如下：

代码：

settings.py（定义一些必须的基本属性和初始值）

class Settings():
    def __init__(self):
        self.screen_width = 1200
        self.screen_height = 600

star.py（为了实现星星大小不一，使用smoothscale进行缩放，缩放值随机）

import pygame
from pygame.sprite import Sprite
from random import randint
class Star(Sprite):
    def __init__(self):
        # 继承父类
        super(Star, self).__init__()
        # 加载图片
        self.image = pygame.image.load('../images/star.png')
        # 平滑缩放到（宽，高）
        random_number = randint(10, 30)
        self.image = pygame.transform.smoothscale(self.image, (random_number, random_number))
        self.rect = self.image.get_rect()

game_functions.py（可修改数字5来控制星星显示疏密）

from star import Star
from random import randint
def create_stars(settings, stars):
    star = Star()
    # 数字5（越大越少）控制疏密
    number_stars_x = int(settings.screen_width / (5 * star.rect.width))
    number_stars_y = int(settings.screen_height / (5 * star.rect.height))
    for number_y in range(number_stars_y):
        for number_x in range(number_stars_x):
            random_number_x = randint(0, settings.screen_width)
            random_number_y = randint(0, settings.screen_height)
            star = Star()
            # # 规则排列
            # star.rect.x = 2 * star.rect.width * number_x
            # star.rect.y = 2 * star.rect.height * number_y
            # 不规则排列
            star.rect.x = random_number_x
            star.rect.y = random_number_y
            stars.add(star)

babysbreath.py（主函数）

import pygame
import sys
from pygame.sprite import Group
from settings import Settings
import game_functions as gf
def run_game():
    pygame.init()
    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('满天星')
    stars = Group()
    gf.create_stars(settings, stars)
    stars.draw(screen)
    while True:
        # 需加事件，不然秒退
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
        # 让最近绘制的屏幕可见
        pygame.display.flip()
run_game()

13-4 连绵细雨 ：修改为完成练习 13-3 而编写的代码，使得一行雨滴消失在屏幕底端后，屏幕顶端又出现一行新雨滴，并开始往下落。

优化为“下雨天”，效果如下图：

代码：

settings.py（定义一些必须的基本属性和初始值）

class Settings():
    def __init__(self):
        self.screen_width = 1200
        self.screen_height = 600

raindrop.py（为了效果更逼真，雨滴落下速度使用随机数random_number / 5）

import pygame
from pygame.sprite import Sprite
from random import randint
class Raindrop(Sprite):
    def __init__(self):
        # 继承父类
        super(Raindrop, self).__init__()
        # 加载图片
        self.image = pygame.image.load('../images/raindrop.png')
        # 平滑缩放到（宽，高）
        random_number = randint(10, 30)
        self.image = pygame.transform.smoothscale(self.image, (random_number, random_number))
        self.rect = self.image.get_rect()
    def update(self):
        """向下移动雨滴"""
        random_number = randint(1, 10)
        self.rect.y += random_number / 5

game_functions.py（使用random_number_y = randint(0, 300)，让雨从半空飘落）

from raindrop import Raindrop
from random import randint
def create_raindrops(settings, raindrops):
    """创建很多雨滴"""
    raindrop = Raindrop()
    # 数字4（越大越少）控制稀疏
    number_raindrops_x = int(settings.screen_width / (4 * raindrop.rect.width))
    number_raindrops_y = int(settings.screen_height / (4 * raindrop.rect.height))
    for number_y in range(number_raindrops_y):
        for number_x in range(number_raindrops_x):
            create_raindrop(raindrops)
def update_raindrops(screen, raindrops):
    """更新所有雨滴的位置"""
    screen_rect = screen.get_rect()
    for raindrop in raindrops.sprites():
        if raindrop.rect.bottom >= screen_rect.bottom:
            raindrops.remove(raindrop)
            create_raindrop(raindrops)
    raindrops.update()
def create_raindrop(raindrops):
    """创建单个雨滴"""
    random_number_x = randint(0, 1200)
    random_number_y = randint(0, 300)
    raindrop = Raindrop()
    # 不规则排列
    raindrop.rect.x = random_number_x
    raindrop.rect.y = random_number_y
    raindrops.add(raindrop)

rain.py（主函数）

import pygame
import sys
from pygame.sprite import Group
from settings import Settings
import game_functions as gf
def run_game():
    pygame.init()
    settings = Settings()
    screen = pygame.display.set_mode((settings.screen_width, settings.screen_height))    
    pygame.display.set_caption('下雨天')
    raindrops = Group()
    gf.create_raindrops(settings, raindrops)    
    while True:
        # 设置背景色（不设置会导致雨滴整个拖下来）
        screen.fill((125, 125, 125))
        # 需加事件，不然秒退
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
        gf.update_raindrops(screen, raindrops)
        raindrops.draw(screen)
        # 让最近绘制的屏幕可见
        pygame.display.flip()
run_game()

13-5 抓球 ：创建一个游戏，在屏幕底端放置一个玩家可左右移动的角色。让一个球出现在屏幕顶端，且水平位置是随机的，并让这个球以固定的速度往下落。如果角色与球发生碰撞（表示将球抓住了），就让球消失。每当角色抓住球或球因抵达屏幕底端而消失后，都创建一个新球。
13-6 游戏结束 ：在为完成练习 13-5 而编写的代码中，跟踪玩家有多少次未将球接着。在未接着球的次数到达三次后，结束游戏。

合并为一个“抓球游戏”，效果图如下（详细查看https://jingyan.baidu.com/article/597a0643bcb5a5712a524311.html）：

代码：

settings.py（定义一些必须的基本属性和初始值）

class Settings():
    def __init__(self):
        self.screen_width = 1200
        self.screen_height = 600
        self.bg_color = (230, 230, 230)
        # 人移动速度
        self.people_move_speed = 1.5
        # 球落下速度
        self.ball_drop_speed = 0.5
        #统计信息设置 
        # 游戏得分
        self.game_score = 0
        # 接到一个球多少分
        self.ball_score = 10
        # 丢失多少球结束游戏
        self.ball_miss_number = 3

ball.py（因为有两处用到球图片，只是大小不一致，定义一个缩放函数scale）

import pygame
from pygame.sprite import Sprite
class Ball(Sprite):
    def __init__(self, settings):
        super(Ball, self).__init__()
        self.settings = settings
        self.image = pygame.image.load('../images/ball.png')
        self.rect = self.image.get_rect()
        self.center = float(self.rect.centerx)
    def scale(self, multiple):
        # 图片缩放
        self.image = pygame.transform.smoothscale(self.image, (multiple, multiple))
    def update(self):
        # 球落下
        self.center += self.settings.ball_drop_speed
        self.rect.centery = self.center

people.py（self.center = float(self.rect.centerx)，因为设置的移动速度存在小数位，这里要加上float，不然效果会有问题）

import pygame
class People():
    def __init__(self, settings, screen):
        self.settings = settings
        self.screen = screen
        self.image = pygame.image.load('../images/people.png')
        self.rect = self.image.get_rect()
        # 人初始位置
        self.screen_rect = self.screen.get_rect()
        self.rect.centerx = self.screen_rect.centerx
        self.rect.bottom = self.screen_rect.bottom
         # 在飞船的属性 center 中存储小数值（不然会导致小数位不起作用）
        self.center = float(self.rect.centerx)
        # 移动标志
        self.moving_right = False
        self.moving_left = False
    def update(self):
        """ 根据移动标志调整人的位置 """
        # 更新人的 center 值，而不是 rect
        if self.moving_right and self.rect.right < self.screen_rect.right:
            self.center += self.settings.people_move_speed
        if self.moving_left and self.rect.left > 0:
            self.center -= self.settings.people_move_speed
        # 根据 self.center 更新 rect 对象
        self.rect.centerx = self.center
    def blitme(self):
        """绘制人"""
        # blit绘制到缓冲区，不显示于屏幕（需要flip才能显示到屏幕）
        self.screen.blit(self.image, self.rect)

button.py

import pygame.font
class Button():
    def __init__(self, screen, msg):
        """初始化按钮的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        # 设置按钮的尺寸和其他属性
        self.width, self.height = 150, 50
        self.button_color = (125, 125, 125)
        self.text_color = (255, 255, 255)
        self.font = pygame.font.SysFont(None, 30)
        # 创建按钮的rect对象，并使其居中
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        # 按钮的标签只需创建一次
        self.prep_msg(msg)
    def prep_msg(self, msg):
        """将msg渲染为图像，并使其在按钮上居中"""
        self.rect.center = self.screen_rect.center
        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（由于绘制左上角的球图片缩小了，所以球之间的间距也要按比例缩小“ball.rect.x”）

import pygame
from pygame.sprite import Group
from ball import Ball
class Scoreboard():
    """docstring for Scoreboard"""
    def __init__(self, settings, screen):
        self.settings = settings
        self.screen = screen
        self.screen_rect = screen.get_rect()
        # 球缩放值
        self.scaleValue = 20
        # 显示得分信息时使用的字体设置
        self.text_color = (30, 30, 30)
        self.font = pygame.font.SysFont(None, 48)
        self.prep_score()
        self.prep_balls()
    def prep_score(self):
        """将得分转换为渲染的图像"""
        rounded_score = int(round(self.settings.game_score, -1))
        score_str = '{:,}'.format(rounded_score)
        self.score_image = self.font.render(score_str, True, self.text_color, self.settings.bg_color)
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 10
        self.score_rect.top = 10        
    def prep_balls(self):
        # 显示还能丢失多少球
        self.balls = Group()
        for number in range(self.settings.ball_miss_number):
            ball = Ball(self.settings)
            # 缩放球大小并赋值位置
            ball.scale(self.scaleValue)
            ball.rect.x = 10 + ball.rect.width * (self.scaleValue / ball.rect.width) * number
            ball.rect.y = 10
            self.balls.add(ball)
    def show_score(self):
        self.balls.draw(self.screen)
        self.screen.blit(self.score_image, self.score_rect)

game_functions.py

import sys
import pygame
from ball import Ball
from button import Button
from random import randint
# 事件
def check_events(people):
    """ 响应按键和鼠标事件 """
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event, people)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event, people)
def check_keydown_events(event, people):
    """ 响应按键 """
    if event.key == pygame.K_RIGHT:
        people.moving_right = True
    elif event.key == pygame.K_LEFT:
        people.moving_left = True
    elif event.key == pygame.K_q:
        sys.exit()
def check_keyup_events(event, people):
    """ 响应松开 """
    if event.key == pygame.K_RIGHT:
        people.moving_right = False
    elif event.key == pygame.K_LEFT:
        people.moving_left = False
# 球
def update_balls(settings, balls, people, screen, scoreboard):
    """更新球的位置"""
    # 创建球（一直1个）
    if len(balls) == 0:
        create_ball(settings, balls, screen)
    # 球碰撞到人，就消失
    if pygame.sprite.spritecollideany(people, balls):
        balls.empty()
        settings.game_score += settings.ball_score
        scoreboard.prep_score()
    # 球到底则消失
    screen_rect = screen.get_rect()
    for ball in balls.sprites():
        if ball.rect.bottom >= screen_rect.bottom:
            balls.remove(ball)
            # 减少可落下的数量并更新显示球数量
            settings.ball_miss_number -= 1
            scoreboard.prep_balls()
    # 当球未接住的数据达到设置的数量，则绘制“Game Over”并结束游戏
    if settings.ball_miss_number == 0:
        button = Button(screen, 'Game Over')
        button.draw_button()
        return
    balls.update()
def create_ball(settings, balls, screen):
    """创建单个球"""
    ball = Ball(settings)
    # 球初始位置（顶部，水平位置随机）
    screen_rect = screen.get_rect()
    number_x = randint(0, settings.screen_width)
    ball.rect.centerx = number_x
    ball.rect.top = screen_rect.top
    balls.add(ball)

catchball.py（主函数）

import pygame
from pygame.sprite import Group
from settings import Settings
import game_functions as gf
from people import People
from scoreboard import Scoreboard
def run_game():
    pygame.init()
    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('抓球')
    # 创建人和球
    people = People(settings, screen)    
    # 创建球的编组
    balls = Group()
    # 创建记分牌
    scoreboard = Scoreboard(settings, screen)
    while True:
        # 设置背景色
        screen.fill(settings.bg_color)
        # 检查玩家输入
        gf.check_events(people)
        # 更新人位置并绘制到屏幕
        people.update()
        people.blitme()
        # 更新球位置并绘制到屏幕
        gf.update_balls(settings, balls, people, screen, scoreboard)
        balls.draw(screen)
        # 显示得分
        scoreboard.show_score()
        # 让最近绘制的屏幕可见
        pygame.display.flip()
run_game()

　　Tips：所使用的图标可自行上“https://www.iconfont.cn/”查找。