20230616223234-header.png

现在是时候来看我们的第一个设计模式了:游戏循环模式(Game Loop Pattern)!这个模式可以为我们提供许多很好的思路,以非常有效的方式重构我们的游戏

游戏循环模式

游戏循环模式有几个不同的版本。这里我介绍一个简单的情况,使用单线程。以下5个函数组成了这个模式:
20230616235132-08_gameloop.png

  • init()函数在启动时被调用,用于初始化游戏及其数据。在接下来的内容中,我将这些数据称为游戏状态(game state)
  • processInput()函数在每次游戏迭代中被调用,用于处理控制输入(键盘、鼠标、手柄)。
    update()函数用于改变游戏状态。processInput()的结果被用于更新游戏状态,同时也可以包含自动处理的过程。
  • render()函数负责处理显示,它将游戏状态转化为可视内容。
  • run()函数包含了游戏循环。在许多情况下,这个循环看起来像下面这样:

    def run():

     init() 
     while True: 
         processInput() 
         update() 
         render()
    

游戏循环模式,就像其他模式一样,是一个为解决问题提供思路的方案。并没有唯一的使用方式:它取决于具体情况。

遵循模式的使用强迫你考虑可能没有想到的问题。例如,在创建“猜数字”游戏时,将用户输入、数据更新和渲染分开可能不是首先想到的。然而,根据经验丰富的开发者的说法,这种分离是至关重要的。所以,作为初学者,我们现在遵循这个建议,以后会理解它为什么重要。并且请相信我:当你理解了这些想法背后的所有精妙之处时,你会感到惊叹不已!

猜数字游戏: init()函数

从这个循环模式的init函数入手:

def init():    
    return None, random.randint(1,10)

这个函数返回一个初始游戏状态。我将游戏数据称为“游戏状态”,因为游戏可以被看作是有限状态机。对于这个游戏,状态包括:

  • 游戏状态:表示游戏的整体状态的字符串:

    • "win":玩家获胜并结束游戏;
    • "end":玩家离开游戏;
    • "lower":玩家仍在游戏中,并提供了一个比魔术数字小的数字;
    • "higher":同样,但是为一个比魔术数字大的数字。
  • 魔术数字:玩家需要猜测的数字。

将所有的游戏数据捆绑在一起是一个重要的任务;我们将在接下来的文章中详细讨论这个问题。

猜数字游戏:processInput()函数

def processInput():
    while True:
        word = input("What is the magic number? ")
        if word == "quit":
            return None

        try:
            playerNumber = int(word)
            break
        except ValueError:
            print("Please type a number without decimals!")
            continue

    return playerNumber

这个函数要求玩家输入一个数字。它处理与用户输入相关的所有问题,比如检查输入的数字是否正确。它返回输入的数字,如果玩家想要停止游戏,则返回None。

对于使用这个函数的用户(比如run()函数),它就像一个神奇的盒子,返回玩家的指令。收集这些指令的方式并不重要。可以是通过键盘、鼠标、手柄、网络甚至是通过人工智能来获取。

猜数字游戏: update()函数

update()函数使用玩家的指令来更新游戏状态:

def update(gameStatus,magicNumber,playerNumber):
    if playerNumber is None:
        gameStatus = "end"
    elif playerNumber == magicNumber:
        gameStatus = "win"
    elif magicNumber < playerNumber:
        gameStatus = "lower"
    elif magicNumber > playerNumber:
        gameStatus = "higher"

return gameStatus, magicNumber 

在我们的情况下,玩家的指令是playerNumber,而游戏状态和魔术数字形成了游戏状态。根据playerNumber的值,函数会更新游戏状态。

需要注意的是,我们没有将gameStatus作为输入,也从未更改magicNumber的值。所以,我们可以考虑从参数中移除gameStatus,以及从返回值中移除magicNumber。除非这是游戏的最终版本,并且必须减少计算复杂性,否则这并不是一个好主意。也许在游戏的未来改进中,我们需要根据gameStatus更新游戏,或者改变magicNumber的值。从设计的角度来看,当前的输入和输出定义是稳健的,没有改变的理由。

猜数字游戏: render()函数

render()函数用于显示当前的游戏状态。它应该无论发生什么都能正常工作,始终清晰地展示游戏的情况:

def render(gameStatus,magicNumber):
    if gameStatus == "win":
        print("This is correct! You win!")
    elif gameStatus == "end":
        print("Bye!")
    elif gameStatus == "lower":
        print("The magic number is lower")
    elif gameStatus == "higher":
        print("The magic number is higher")
    else:
        raise RuntimeError("Unexpected game status {}".format(gameStatus))

这个函数的输入是游戏状态,没有输出。过程很简单:根据gameStatus的值显示相应的消息。

需要注意的是,我们还处理了gameStatus具有意外值的情况。这是一个好习惯,它在你更新游戏并忘记更新某些部分时非常有帮助。

猜数字游戏:runGame()函数

def runGame():
    gameStatus, magicNumber = init()
    while gameStatus != "win" and gameStatus != "end":
        playerNumber = processInput()
        gameStatus, magicNumber = update(gameStatus,magicNumber,playerNumber)
        render(gameStatus,magicNumber)

你可以看到流程如下:

  • init()函数返回一个初始的游戏状态;
  • processInput()函数从玩家那里收集指令;
  • update()函数使用指令来更新游戏状态;
  • render()函数显示游戏状态。

猜数字游戏:最终代码

# Import the random package
import random

def init():
    """
    Initialize game

    Outputs:
      * gameStatus
      * magicNumber
    """
    # Generate a random Magic number
    return None, random.randint(1,10)


def processInput():
    """
    Handle player's input

    Output:
      * playerNumber: the number entered by the player, or None if the player wants to stop the game
    """

    while True:
        # Player input
        word = input("What is the magic number? ")
        # Quit if the player types "quit"
        if word == "quit":
            return None

        # Int casting with exception handling
        try:
            playerNumber = int(word)
            break
        except ValueError:
            print("Please type a number without decimals!")
            continue

    return playerNumber

def update(gameStatus,magicNumber,playerNumber):
    """
    Update game state

    Inputs:
      * gameStatus: the status of the game
      * magicNumber: the magic number to find
      * playerNumber: the number entered by the player
    Output:
      * gameStatus: the status of the game
      * magicNumber: the magic number to find
    """
    if playerNumber is None:
        gameStatus = "end"
    elif playerNumber == magicNumber:
        gameStatus = "win"
    elif magicNumber < playerNumber:
        gameStatus = "lower"
    elif magicNumber > playerNumber:
        gameStatus = "higher"

    return gameStatus, magicNumber

def render(gameStatus,magicNumber):
    """
    Render game state

    Input:
      * gameStatus: the status of the game, "win", "end", "lower" or "higher"
    """
    # Cases
    if gameStatus == "win":
        print("This is correct! You win!")
    elif gameStatus == "end":
        print("Bye!")
    elif gameStatus == "lower":
        print("The magic number is lower")
    elif gameStatus == "higher":
        print("The magic number is higher")
    else:
        raise RuntimeError("Unexpected game status {}".format(gameStatus))

def runGame():
    gameStatus, magicNumber = init()
    while gameStatus != "win" and gameStatus != "end":
        playerNumber = processInput()
        gameStatus, magicNumber = update(gameStatus,magicNumber,playerNumber)
        render(gameStatus,magicNumber)


# Launch the game
runGame()

游戏循环模式有助于帮助我们合理组织代码,适应更复杂的程序设计!!

b252115c-ce75-41f9-b6e4-b9a211019686.jpeg

充分使用游戏素材,展示动画特效

主要思路比较直观:

  • 加载一些列游戏素材图片
  • 获取鼠标点击位置
  • 顺序播放一系列图片帧,获得爆炸效果

效果如下:
20230611034352- 2023-06-11 03-43-36.png

  • 加载素材

    explosion_frames = []

     for i in range(16):
         img = pygame.image.load(f"explosion/frame{i:04}.png")
         explosion_frames.append(img)
    
  • 获取鼠标位置

    # 处理鼠标点击事件

         if event.type == pygame.MOUSEBUTTONDOWN:
             mouse_x, mouse_y = event.pos
             #if button_x <= mouse_x <= button_x + button_width and button_y <= mouse_y <= button_y + button_height:
             explosion_playing = True
    
  • 绘制系列图片

    if explosion_playing:

         if frame_index < len(explosion_frames):
             frame = explosion_frames[frame_index]
             game_display.blit(frame, (mouse_x, mouse_y))
             frame_index += 1
             pygame.time.wait(100)
         else:
             explosion_playing = False
             frame_index = 0
    

完整代码如下:

import pygame

pygame.init()

# 窗口尺寸
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))

# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

# 按钮尺寸和位置
button_width = 80
button_height = 40
button_x = width // 2 - button_width // 2
button_y = height // 2 - button_height // 2

# 加载爆炸动画帧
explosion_frames = []
for i in range(16):
    img = pygame.image.load(f"explosion/frame{i:04}.png")
    explosion_frames.append(img)

# 当前动画帧索引
frame_index = 0

# 爆炸动画是否正在播放
explosion_playing = False

# 游戏主循环
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        # 处理鼠标点击事件
        if event.type == pygame.MOUSEBUTTONDOWN:
            mouse_x, mouse_y = event.pos
            #if button_x <= mouse_x <= button_x + button_width and button_y <= mouse_y <= button_y + button_height:
            explosion_playing = True

    # 绘制游戏内容
    game_display.fill(BLACK)  # 填充窗口为黑色

    # 绘制按钮
    if explosion_playing:
        if frame_index < len(explosion_frames):
            frame = explosion_frames[frame_index]
            game_display.blit(frame, (mouse_x, mouse_y))
            frame_index += 1
            pygame.time.wait(100)
        else:
            explosion_playing = False
            frame_index = 0
    else:
        pass
        #pygame.draw.rect(game_display, BLUE, (button_x, button_y, button_width, button_height), 2)

    # 更新显示
    pygame.d

isplay.update()

pygame.quit()

explosion-sample.zip

PYPL指数-编程语言流行榜

PYPL指数-编程语言流行榜

PYPL编程语言受欢迎指数是通过分析在Google上搜索语言教程的频率来创建的。

一个语言教程被搜索得越多,就被认为该语言越受欢迎。这是一个领先的指标。原始数据来自Google趋势。

如果你相信集体智慧,PYPL编程语言受欢迎指数可以帮助你决定学习哪种语言,或者在新的软件项目中使用哪种语言。
All.png

Worldwide, Jun 2023 compared to a year ago:

Rank
Change Language Share Trend
1 Python 27.66 % +0.2 %
2 Java 16.16 % -1.3 %
3 JavaScript 9.44 % -0.2 %
4 C# 6.79 % -0.5 %
5 C/C++ 6.6 % -0.1 %
6 PHP 5.04 % -0.4 %
7 R 4.17 % -0.3 %
8 TypeScript 3.11 % +0.5 %
9 Swift 2.38 % +0.2 %
10 Rust 2.24 % +0.8 %
11 Objective-C 2.07 % -0.1 %
12 Go 2.02 % +0.3 %
13 Kotlin 1.82 % +0.1 %
14 Matlab 1.55 % -0.2 %
15 Ruby 1.12 % +0.2 %
16 Ada 0.97 % +0.3 %
17 Powershell 0.94 % +0.2 %
18 VBA 0.87 % -0.0 %
19 Dart 0.82 % -0.0 %
20 Lua 0.64 % +0.1 %
21 Scala 0.59 % -0.1 %
22 Abap 0.53 % +0.1 %
23 Visual Basic 0.48 % -0.1 %
24 Julia 0.42 % +0.0 %
25 Groovy 0.42 % +0.0 %
26 Cobol 0.41 % +0.2 %
27 Perl 0.35 % +0.1 %
28 Haskell 0.24 % -0.0 %
29 Delphi/Pascal 0.14 % +0.1 %
© Pierre Carbonnelle, 2023

其他指数可以参考PYPL主页

黑白棋

完善黑白棋

之前简单构建了黑白棋框架,只是渲染界面,并没有实际黑白棋运行逻辑: 如何反转棋子?

增加翻转棋子的功能
修改make_move函数,判断需要翻转的棋子,加入到list里面,然后设置一个便利flipped
鼠标点击的时候,判断是否flipped,则重新绘制draw_board
增加棋盘上的格子线
使用pygame.color函数定义一些常量



import pygame
import sys

# 游戏参数
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
BOARD_SIZE = 8
CELL_SIZE = SCREEN_HEIGHT // BOARD_SIZE

# 颜色定义
# 颜色定义
BLACK = pygame.Color('black')
WHITE = pygame.Color('white')
BLUE = pygame.Color('blue')
GREEN = pygame.Color('green')
YELLOW = pygame.Color('yellow')



def create_board():
    board = [[' ' for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
    board[3][44] = 'W'
    board[3][45] = 'B'
    board[4][46] = 'B'
    board[4][47] = 'W'
    return board


def draw_board(screen, board, player):
    screen.fill(GREEN)

    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            pygame.draw.rect(screen, BLUE, (col * CELL_SIZE, row * CELL_SIZE, CELL_SIZE, CELL_SIZE))

            
            if board[row][col] == 'W':
                pygame.draw.circle(screen, WHITE,
                                   (col * CELL_SIZE + CELL_SIZE // 2, row * CELL_SIZE + CELL_SIZE // 2),
                                   CELL_SIZE // 2 - 4)
                
            elif board[row][col] == 'B':
                pygame.draw.circle(screen, BLACK,
                                   (col * CELL_SIZE + CELL_SIZE // 2, row * CELL_SIZE + CELL_SIZE // 2),
                                   CELL_SIZE // 2 - 4)
    if player == 'W':
        pygame.draw.circle(screen, WHITE,
                                   (540, 80),
                                   CELL_SIZE // 2 - 4)
    else:
        pygame.draw.circle(screen, BLACK,
                                   (540, 80),
                                   CELL_SIZE // 2 - 4)
    # 绘制格子线
    for i in range(BOARD_SIZE + 1):
        pygame.draw.line(screen, YELLOW, (0, i * CELL_SIZE), (SCREEN_WIDTH, i * CELL_SIZE))
        pygame.draw.line(screen, YELLOW, (i * CELL_SIZE, 0), (i * CELL_SIZE, SCREEN_HEIGHT))


    pygame.display.flip()


def is_valid_move(board, row, col, player):
    if board[row][col] != ' ':
        return False

    other_player = 'B' if player == 'W' else 'W'
    directions = [(0, -1), (0, 1), (-1, 0), (1, 0),
                  (-1, -1), (-1, 1), (1, -1), (1, 1)]

    for drow, dcol in directions:
        r, c = row, col
        r += drow
        c += dcol

        if (0 <= r < BOARD_SIZE) and (0 <= c < BOARD_SIZE) and (board[r][c] == other_player):
            r += drow
            c += dcol

            while (0 <= r < BOARD_SIZE) and (0 <= c < BOARD_SIZE):
                if board[r][c] == player:
                    return True
                elif board[r][c] == ' ':
                    break
                r += drow
                c += dcol

    return False


def make_move(board, row, col, player):
    if not is_valid_move(board, row, col, player):
        return False

    other_player = 'B' if player == 'W' else 'W'
    board[row][col] = player
    directions = [(0, -1), (0, 1), (-1, 0), (1, 0),
                  (-1, -1), (-1, 1), (1, -1), (1, 1)]

    flipped = False

    for drow, dcol in directions:
        r, c = row, col
        r += drow
        c += dcol

        if (0 <= r < BOARD_SIZE) and (0 <= c < BOARD_SIZE) and (board[r][c] == other_player):
            flip_list = []
            while (0 <= r < BOARD_SIZE) and (0 <= c < BOARD_SIZE):
                if board[r][c] == player:
                    flipped = True
                    for flip_row, flip_col in flip_list:
                        board[flip_row][flip_col] = player
                    break
                elif board[r][c] == ' ':
                    break
                else:
                    flip_list.append((r, c))
                r += drow
                c += dcol

    return flipped




def is_game_over(board):
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col] == ' ':
                return False
    return True


def count_pieces(board):
    black_count = 0
    white_count = 0
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col] == 'B':
                black_count += 1
            elif board[row][col] == 'W':
                white_count += 1
    return black_count, white_count


def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("黑白棋游戏")
    clock = pygame.time.Clock()

    board = create_board()
    current_player = 'B'

    while not is_game_over(board):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

            if event.type == pygame.MOUSEBUTTONDOWN:
                mouse_x, mouse_y = pygame.mouse.get_pos()
                col = mouse_x // CELL_SIZE
                row = mouse_y // CELL_SIZE

                if make_move(board, row, col, current_player):
                    current_player = 'W' if current_player == 'B' else 'B'
                    draw_board(screen, board, current_player)

        draw_board(screen, board, current_player)
        black_count, white_count = count_pieces(board)
        pygame.display.set_caption(f"黑棋: {black_count}  白棋: {white_count}")

        pygame.display.flip()
        clock.tick(60)

    black_count, white_count = count_pieces(board)
    pygame.display.set_caption(f"黑棋: {black_count}  白棋: {white_count}")

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()


if __name__ == '__main__':
    main()


程序解释

make_move函数解释:

  • 函数的输入参数包括:

    • board:当前游戏棋盘的状态,是一个二维列表,表示每个位置上的棋子情况。
    • row、col:玩家希望在棋盘上放置棋子的行和列索引。
    • player:当前玩家的标识符,可以是'W'(白棋)或'B'(黑棋)。

函数的返回值为布尔值,表示移动是否有效。如果移动有效,会更新棋盘的状态,将当前玩家的棋子放置在指定的位置,并将被翻转的对方棋子也进行翻转。如果移动无效,不会有任何改变。

  • 函数的主要步骤如下:

    1. 首先检查指定位置是否是有效的落子位置,通过调用is_valid_move函数进行判断。如果无效,则返回False表示移动无效。
    2. 如果移动有效,将当前玩家的棋子放置在指定位置boardrow = player。
    3. 接下来,遍历八个方向的偏移量,表示在该方向上搜索对方棋子是否可以被翻转。
    4. 对于每个方向,根据偏移量从指定位置开始向该方向前进,如果遇到对方棋子,则继续前进直到遇到空格、边界或当前玩家的棋子。
    5. 如果在该方向上遇到了当前玩家的棋子,将之前记录的需要翻转的对方棋子进行翻转操作,即将boardflip_row设置为当前玩家的棋子。
    6. 最后,返回True表示移动有效。

is_valid_move

  • 函数的输入参数包括:

    • board:当前游戏棋盘的状态,是一个二维列表,表示每个位置上的棋子情况。
    • row、col:玩家希望在棋盘上放置棋子的行和列索引。
    • player:当前玩家的标识符,可以是'W'(白棋)或'B'(黑棋)。

函数的返回值为布尔值,表示移动是否有效。如果移动有效,返回True;如果移动无效,返回False。

  • 函数的主要步骤如下:

    1. 首先,检查指定位置上是否已经有棋子。如果该位置已经有棋子,则返回False表示移动无效。
    2. 确定对方玩家的标识符。如果当前玩家是白棋('W'),则对方玩家是黑棋('B');反之亦然。
    3. 遍历八个方向的偏移量,表示在该方向上搜索对方棋子。
    4. 对于每个方向,从指定位置开始向该方向前进,如果遇到对方玩家的棋子,则继续前进直到遇到空格、边界或当前玩家的棋子。
    5. 如果在该方向上遇到了当前玩家的棋子,说明在该方向上可以进行翻转操作,表示移动有效,返回True。
    6. 如果在所有方向上都没有找到可以翻转的对方棋子,则移动无效,返回False。

create_board函数:

  • 函数的主要步骤如下:

    1. 创建一个二维列表 board,用于表示黑白棋盘。列表的行数和列数都为 BOARD_SIZE,每个元素初始值为 ' ',表示空格。
    2. 将黑棋和白棋的初始位置设置在棋盘的中心,即第3行第3列、第3行第4列、第4行第3列和第4行第4列。将这些位置上的元素分别设置为 'W' 和 'B',表示白棋和黑棋。
    3. 返回创建好的棋盘 board。

create_board函数创建一个初始状态的黑白棋棋盘,并返回该棋盘。每个棋子的位置由特定的字符表示,空格表示未放置棋子的位置,'W' 表示白棋,'B' 表示黑棋。

  • Direction 8个方向定义:

directions列表中的元素表示了八个方向,每个元素是一个包含两个整数的元组,分别表示在行和列上的移动偏移量。下面是对每个元素所代表的方向的解释:

1. (0, -1):向左移动一列
2. (0, 1):向右移动一列
3. (-1, 0):向上移动一行
4. (1, 0):向下移动一行
5. (-1, -1):向左上方移动一行一列
6. (-1, 1):向右上方移动一行一列
7. (1, -1):向左下方移动一行一列
8. (1, 1):向右下方移动一行一列

这些方向涵盖了棋子可以进行的所有移动方向,包括水平、垂直和对角线方向。
在黑白棋游戏中,通过遍历这些方向,并在棋盘上按照相应的偏移量移动,可以判断该位置是否为有效的落子位置,并且可以在落子时翻转对方的棋子。

pgzero 配置环境

pgzero环境配置

  • 创建python虚拟环境

    python3 -m venv pgzero_venv

  • 激活python虚拟环境

    source pgzero_venv/bin/activate ## On Linux
    pgzero_venv/bin/activate.bat ## on Windows

  • 安装pgzero
 pip install pgzero
  • 运行pgzero程序

    pgzrun xxx.py ##在Windows平台默认pgzrun不在path环境变量里,需要设置一下,或者使用pgzrun全路径